d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MFp4:

Browse Source 
Completely remove the remaining EFI includes and add our own (type)
definitions instead. While here, abstract more of the internals by
providing interface functions.
This commit is contained in:
marcel 2004-09-19 03:50:46 +00:00
parent 78d7eda383
commit 60944a9fd4
8 changed files with 364 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
sys/ia64/acpica/OsdEnvironment.c
View File

@ -23,58 +23,52 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/*
* 6.1 : Environmental support
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include <sys/linker_set.h>
#include <sys/sysctl.h>
#include <machine/efi.h>
#include "acpi.h"
extern u_int64_t ia64_efi_acpi_table;
extern u_int64_t ia64_efi_acpi20_table;
static struct uuid acpi_root_uuid = EFI_TABLE_ACPI20;
static u_long ia64_acpi_root;
static u_long acpi_root_phys;
SYSCTL_ULONG(_machdep, OID_AUTO, acpi_root, CTLFLAG_RD, &ia64_acpi_root, 0,
"The physical address of the RSDP");
SYSCTL_ULONG(_machdep, OID_AUTO, acpi_root, CTLFLAG_RD, &acpi_root_phys, 0,
"The physical address of the RSDP");
ACPI_STATUS
AcpiOsInitialize(void)
{
return(AE_OK);
}
ACPI_STATUS
AcpiOsTerminate(void)
{
return(AE_OK);
}
ACPI_STATUS
AcpiOsGetRootPointer(UINT32 Flags, ACPI_POINTER *RsdpAddress)
{
if (ia64_acpi_root == 0) {
if (ia64_efi_acpi20_table) {
/* XXX put under bootverbose. */
printf("Using ACPI2.0 table at 0x%lx\n",
ia64_efi_acpi20_table);
ia64_acpi_root = ia64_efi_acpi20_table;
} else if (ia64_efi_acpi_table) {
/* XXX put under bootverbose. */
printf("Using ACPI1.x table at 0x%lx\n",
ia64_efi_acpi_table);
ia64_acpi_root = ia64_efi_acpi_table;
} else
void *acpi_root;
if (acpi_root_phys == 0) {
acpi_root = efi_get_table(&acpi_root_uuid);
if (acpi_root == NULL)
return (AE_NOT_FOUND);
acpi_root_phys = IA64_RR_MASK((u_long)acpi_root);
}
RsdpAddress->PointerType = ACPI_PHYSICAL_POINTER;
RsdpAddress->Pointer.Physical = ia64_acpi_root;
RsdpAddress->Pointer.Physical = acpi_root_phys;
return (AE_OK);
}

49
sys/ia64/ia64/dump_machdep.c
View File

@ -22,10 +22,11 @@
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
@ -34,7 +35,6 @@
#include <sys/kerneldump.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <machine/bootinfo.h>
#include <machine/efi.h>
#include <machine/elf.h>
#include <machine/md_var.h>
@ -50,7 +50,7 @@ CTASSERT(sizeof(struct kerneldumpheader) == 512);
#define MD_ALIGN(x) (((off_t)(x) + EFI_PAGE_MASK) & ~EFI_PAGE_MASK)
#define DEV_ALIGN(x) (((off_t)(x) + (DEV_BSIZE-1)) & ~(DEV_BSIZE-1))
typedef int callback_t(EFI_MEMORY_DESCRIPTOR*, int, void*);
typedef int callback_t(struct efi_md*, int, void*);
static struct kerneldumpheader kdh;
static off_t dumplo, fileofs;
@ -121,7 +121,7 @@ buf_flush(struct dumperinfo *di)
}
static int
cb_dumpdata(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
cb_dumpdata(struct efi_md *mdp, int seqnr, void *arg)
{
struct dumperinfo *di = (struct dumperinfo*)arg;
vm_offset_t pa;
@ -129,11 +129,11 @@ cb_dumpdata(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
size_t counter, sz;
int c, error, twiddle;
error = 0; /* catch case in which mdp->NumberOfPages is 0 */
error = 0; /* catch case in which mdp->md_pages is 0 */
counter = 0; /* Update twiddle every 16MB */
twiddle = 0;
pgs = mdp->NumberOfPages;
pa = IA64_PHYS_TO_RR7(mdp->PhysicalStart);
pgs = mdp->md_pages;
pa = IA64_PHYS_TO_RR7(mdp->md_phys);
printf(" chunk %d: %ld pages ", seqnr, (long)pgs);
@ -164,7 +164,7 @@ cb_dumpdata(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
}
static int
cb_dumphdr(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
cb_dumphdr(struct efi_md *mdp, int seqnr, void *arg)
{
struct dumperinfo *di = (struct dumperinfo*)arg;
Elf64_Phdr phdr;
@ -174,10 +174,10 @@ cb_dumphdr(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
phdr.p_type = PT_LOAD;
phdr.p_flags = PF_R; /* XXX */
phdr.p_offset = fileofs;
phdr.p_vaddr = mdp->VirtualStart; /* XXX probably bogus. */
phdr.p_paddr = mdp->PhysicalStart;
phdr.p_filesz = mdp->NumberOfPages << EFI_PAGE_SHIFT;
phdr.p_memsz = mdp->NumberOfPages << EFI_PAGE_SHIFT;
phdr.p_vaddr = (uintptr_t)mdp->md_virt; /* XXX probably bogus. */
phdr.p_paddr = mdp->md_phys;
phdr.p_filesz = mdp->md_pages << EFI_PAGE_SHIFT;
phdr.p_memsz = mdp->md_pages << EFI_PAGE_SHIFT;
phdr.p_align = EFI_PAGE_SIZE;
error = buf_write(di, (char*)&phdr, sizeof(phdr));
@ -186,35 +186,30 @@ cb_dumphdr(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
}
static int
cb_size(EFI_MEMORY_DESCRIPTOR *mdp, int seqnr, void *arg)
cb_size(struct efi_md *mdp, int seqnr, void *arg)
{
uint64_t *sz = (uint64_t*)arg;
*sz += (uint64_t)mdp->NumberOfPages << EFI_PAGE_SHIFT;
*sz += (uint64_t)mdp->md_pages << EFI_PAGE_SHIFT;
return (0);
}
static int
foreach_chunk(callback_t cb, void *arg)
{
EFI_MEMORY_DESCRIPTOR *mdp;
int error, i, mdcount, seqnr;
struct efi_md *mdp;
int error, seqnr;
mdp = (EFI_MEMORY_DESCRIPTOR *)IA64_PHYS_TO_RR7(bootinfo.bi_memmap);
mdcount = bootinfo.bi_memmap_size / bootinfo.bi_memdesc_size;
if (mdp == NULL || mdcount == 0)
return (0);
for (i = 0, seqnr = 0; i < mdcount; i++) {
if (mdp->Type == EfiConventionalMemory) {
seqnr = 0;
mdp = efi_md_first();
while (mdp != NULL) {
if (mdp->md_type == EFI_MD_TYPE_FREE) {
error = (*cb)(mdp, seqnr++, arg);
if (error)
return (-error);
}
mdp = NextMemoryDescriptor(mdp, bootinfo.bi_memdesc_size);
mdp = efi_md_next(mdp);
}
return (seqnr);
}

198
sys/ia64/ia64/efi.c
View File

@ -1,4 +1,5 @@
/*-
* Copyright (c) 2004 Marcel Moolenaar
* Copyright (c) 2001 Doug Rabson
* All rights reserved.
*
@ -22,97 +23,134 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <machine/bootinfo.h>
#include <machine/efi.h>
#include <machine/sal.h>
EFI_SYSTEM_TABLE *ia64_efi_systab;
EFI_RUNTIME_SERVICES *ia64_efi_runtime;
u_int64_t ia64_efi_acpi_table;
u_int64_t ia64_efi_acpi20_table;
extern uint64_t ia64_call_efi_physical(uint64_t, uint64_t, uint64_t, uint64_t,
uint64_t, uint64_t);
extern u_int64_t ia64_call_efi_physical(u_int64_t, u_int64_t, u_int64_t,
u_int64_t, u_int64_t, u_int64_t);
static struct efi_systbl *efi_systbl;
static struct efi_cfgtbl *efi_cfgtbl;
static struct efi_rt *efi_runtime;
void
ia64_efi_init(void)
efi_boot_finish(void)
{
EFI_CONFIGURATION_TABLE *conf;
struct sal_system_table *saltab = 0;
EFI_RUNTIME_SERVICES *rs;
EFI_MEMORY_DESCRIPTOR *md, *mdp;
int mdcount, i;
EFI_STATUS status;
if (!bootinfo.bi_systab) {
printf("No system table!\n");
return;
}
ia64_efi_systab = (EFI_SYSTEM_TABLE *)
IA64_PHYS_TO_RR7(bootinfo.bi_systab);
rs = (EFI_RUNTIME_SERVICES *)
IA64_PHYS_TO_RR7((u_int64_t)ia64_efi_systab->RuntimeServices);
if (!rs)
panic("No runtime services!");
ia64_efi_runtime = rs;
conf = (EFI_CONFIGURATION_TABLE *)
IA64_PHYS_TO_RR7((u_int64_t)ia64_efi_systab->ConfigurationTable);
if (!conf)
panic("No configuration tables!");
mdcount = bootinfo.bi_memmap_size / bootinfo.bi_memdesc_size;
md = (EFI_MEMORY_DESCRIPTOR *) IA64_PHYS_TO_RR7(bootinfo.bi_memmap);
for (i = 0, mdp = md; i < mdcount; i++,
mdp = NextMemoryDescriptor(mdp, bootinfo.bi_memdesc_size)) {
/*
* Relocate runtime memory segments for firmware.
*/
if (mdp->Attribute & EFI_MEMORY_RUNTIME) {
if (mdp->Attribute & EFI_MEMORY_WB)
mdp->VirtualStart =
IA64_PHYS_TO_RR7(mdp->PhysicalStart);
else if (mdp->Attribute & EFI_MEMORY_UC)
mdp->VirtualStart =
IA64_PHYS_TO_RR6(mdp->PhysicalStart);
}
}
status = ia64_call_efi_physical((u_int64_t)rs->SetVirtualAddressMap,
bootinfo.bi_memmap_size, bootinfo.bi_memdesc_size,
bootinfo.bi_memdesc_version, bootinfo.bi_memmap, 0);
if (EFI_ERROR(status)) {
/*
* We could wrap EFI in a virtual->physical shim here.
*/
printf("SetVirtualAddressMap returned 0x%lx\n", status);
panic("Can't set firmware into virtual mode");
}
for (i = 0; i < ia64_efi_systab->NumberOfTableEntries; i++) {
static EFI_GUID sal = SAL_SYSTEM_TABLE_GUID;
static EFI_GUID acpi = ACPI_TABLE_GUID;
static EFI_GUID acpi20 = ACPI_20_TABLE_GUID;
if (!memcmp(&conf[i].VendorGuid, &sal, sizeof(EFI_GUID)))
saltab = (struct sal_system_table *)
IA64_PHYS_TO_RR7((u_int64_t) conf[i].VendorTable);
if (!memcmp(&conf[i].VendorGuid, &acpi, sizeof(EFI_GUID)))
ia64_efi_acpi_table = (u_int64_t) conf[i].VendorTable;
if (!memcmp(&conf[i].VendorGuid, &acpi20, sizeof(EFI_GUID)))
ia64_efi_acpi20_table = (u_int64_t) conf[i].VendorTable;
}
if (saltab)
ia64_sal_init(saltab);
}
/*
* Collect the entry points for PAL and SAL. Be extra careful about NULL
* pointer values. We're running pre-console, so it's better to return
* error values than to cause panics, machine checks and other traps and
* faults. Keep this minimal...
*/
int
efi_boot_minimal(uint64_t systbl)
{
struct efi_md *md;
efi_status status;
if (systbl == 0)
return (EINVAL);
efi_systbl = (struct efi_systbl *)IA64_PHYS_TO_RR7(systbl);
if (efi_systbl->st_hdr.th_sig != EFI_SYSTBL_SIG) {
efi_systbl = NULL;
return (EFAULT);
}
efi_cfgtbl = (efi_systbl->st_cfgtbl == 0) ? NULL :
(struct efi_cfgtbl *)IA64_PHYS_TO_RR7(efi_systbl->st_cfgtbl);
if (efi_cfgtbl == NULL)
return (ENOENT);
efi_runtime = (efi_systbl->st_rt == 0) ? NULL :
(struct efi_rt *)IA64_PHYS_TO_RR7(efi_systbl->st_rt);
if (efi_runtime == NULL)
return (ENOENT);
/*
* Relocate runtime memory segments for firmware.
*/
md = efi_md_first();
while (md != NULL) {
if (md->md_attr & EFI_MD_ATTR_RT) {
if (md->md_attr & EFI_MD_ATTR_WB)
md->md_virt =
(void *)IA64_PHYS_TO_RR7(md->md_phys);
else if (md->md_attr & EFI_MD_ATTR_UC)
md->md_virt =
(void *)IA64_PHYS_TO_RR6(md->md_phys);
}
md = efi_md_next(md);
}
status = ia64_call_efi_physical((uint64_t)efi_runtime->rt_setvirtual,
bootinfo.bi_memmap_size, bootinfo.bi_memdesc_size,
bootinfo.bi_memdesc_version, bootinfo.bi_memmap, 0);
return ((status < 0) ? EFAULT : 0);
}
void *
efi_get_table(struct uuid *uuid)
{
struct efi_cfgtbl *ct;
u_long count;
if (efi_cfgtbl == NULL)
return (NULL);
count = efi_systbl->st_entries;
ct = efi_cfgtbl;
while (count--) {
if (!memcmp(&ct->ct_uuid, uuid, sizeof(*uuid)))
return ((void *)IA64_PHYS_TO_RR7(ct->ct_data));
ct++;
}
return (NULL);
}
void
efi_get_time(struct efi_tm *tm)
{
efi_runtime->rt_gettime(tm, NULL);
}
struct efi_md *
efi_md_first(void)
{
if (bootinfo.bi_memmap == 0)
return (NULL);
return ((struct efi_md *)IA64_PHYS_TO_RR7(bootinfo.bi_memmap));
}
struct efi_md *
efi_md_next(struct efi_md *md)
{
uint64_t plim;
plim = IA64_PHYS_TO_RR7(bootinfo.bi_memmap + bootinfo.bi_memmap_size);
md = (struct efi_md *)((uintptr_t)md + bootinfo.bi_memdesc_size);
return ((md >= (struct efi_md *)plim) ? NULL : md);
}
void
efi_reset_system(void)
{
if (efi_runtime != NULL)
efi_runtime->rt_reset(EFI_RESET_WARM, 0, 0, NULL);
panic("%s: unable to reset the machine", __func__);
}
efi_status
efi_set_time(struct efi_tm *tm)
{
return (efi_runtime->rt_settime(tm));
}

43
sys/ia64/ia64/eficlock.c
View File

@ -22,10 +22,11 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
@ -46,17 +47,17 @@ eficlock_init(kobj_t dev)
static void
eficlock_get(kobj_t dev, time_t base, struct clocktime *ct)
{
EFI_TIME time;
struct efi_tm tm;
ia64_efi_runtime->GetTime(&time, 0);
efi_get_time(&tm);
ct->sec = time.Second;
ct->min = time.Minute;
ct->hour = time.Hour;
ct->sec = tm.tm_sec;
ct->min = tm.tm_min;
ct->hour = tm.tm_hour;
ct->dow = 0; /* XXX not used */
ct->day = time.Day;
ct->mon = time.Month;
ct->year = time.Year - 1900;
ct->day = tm.tm_mday;
ct->mon = tm.tm_mon;
ct->year = tm.tm_year - 1900;
}
/*
@ -65,18 +66,18 @@ eficlock_get(kobj_t dev, time_t base, struct clocktime *ct)
static void
eficlock_set(kobj_t dev, struct clocktime *ct)
{
EFI_TIME time;
EFI_STATUS status;
struct efi_tm tm;
efi_status status;
ia64_efi_runtime->GetTime(&time, 0);
time.Second = ct->sec;
time.Minute = ct->min;
time.Hour = ct->hour;
time.Day = ct->day;
time.Month = ct->mon;
time.Year = ct->year + 1900;
status = ia64_efi_runtime->SetTime(&time);
if (status != EFI_SUCCESS)
efi_get_time(&tm);
tm.tm_sec = ct->sec;
tm.tm_min = ct->min;
tm.tm_hour = ct->hour;
tm.tm_mday = ct->day;
tm.tm_mon = ct->mon;
tm.tm_year = ct->year + 1900;
status = efi_set_time(&tm);
if (status)
printf("eficlock_set: could not set TODR\n");
}

56
sys/ia64/ia64/machdep.c
View File

@ -23,10 +23,11 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_compat.h"
#include "opt_ddb.h"
#include "opt_kstack_pages.h"
@ -281,14 +282,14 @@ void
cpu_boot(int howto)
{
ia64_efi_runtime->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, 0);
efi_reset_system();
}
void
cpu_halt()
{
ia64_efi_runtime->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, 0);
efi_reset_system();
}
static void
@ -485,8 +486,8 @@ ia64_init(void)
vm_offset_t kernstart, kernend;
vm_offset_t kernstartpfn, kernendpfn, pfn0, pfn1;
char *p;
EFI_MEMORY_DESCRIPTOR *md, *mdp;
int mdcount, i, metadata_missing;
struct efi_md *md;
int metadata_missing;
/* NO OUTPUT ALLOWED UNTIL FURTHER NOTICE */
@ -516,15 +517,15 @@ ia64_init(void)
* Look for the I/O ports first - we need them for console
* probing.
*/
mdcount = bootinfo.bi_memmap_size / bootinfo.bi_memdesc_size;
md = (EFI_MEMORY_DESCRIPTOR *) IA64_PHYS_TO_RR7(bootinfo.bi_memmap);
for (i = 0, mdp = md; i < mdcount; i++,
mdp = NextMemoryDescriptor(mdp, bootinfo.bi_memdesc_size)) {
if (mdp->Type == EfiMemoryMappedIOPortSpace)
ia64_port_base = IA64_PHYS_TO_RR6(mdp->PhysicalStart);
else if (mdp->Type == EfiPalCode)
ia64_pal_base = mdp->PhysicalStart;
for (md = efi_md_first(); md != NULL; md = efi_md_next(md)) {
switch (md->md_type) {
case EFI_MD_TYPE_IOPORT:
ia64_port_base = IA64_PHYS_TO_RR6(md->md_phys);
break;
case EFI_MD_TYPE_PALCODE:
ia64_pal_base = md->md_phys;
break;
}
}
metadata_missing = 0;
@ -577,7 +578,8 @@ ia64_init(void)
* Wire things up so we can call the firmware.
*/
map_pal_code();
ia64_efi_init();
efi_boot_minimal(bootinfo.bi_systab);
ia64_sal_init();
calculate_frequencies();
/*
@ -627,22 +629,18 @@ ia64_init(void)
#endif
phys_avail_cnt = 0;
for (i = 0, mdp = md; i < mdcount; i++,
mdp = NextMemoryDescriptor(mdp, bootinfo.bi_memdesc_size)) {
for (md = efi_md_first(); md != NULL; md = efi_md_next(md)) {
#ifdef DEBUG_MD
printf("MD %d: type %d pa 0x%lx cnt 0x%lx\n", i,
mdp->Type,
mdp->PhysicalStart,
mdp->NumberOfPages);
printf("MD %p: type %d pa 0x%lx cnt 0x%lx\n", md,
md->md_type, md->md_phys, md->md_pages);
#endif
pfn0 = ia64_btop(round_page(mdp->PhysicalStart));
pfn1 = ia64_btop(trunc_page(mdp->PhysicalStart
+ mdp->NumberOfPages * 4096));
pfn0 = ia64_btop(round_page(md->md_phys));
pfn1 = ia64_btop(trunc_page(md->md_phys + md->md_pages * 4096));
if (pfn1 <= pfn0)
continue;
if (mdp->Type != EfiConventionalMemory)
if (md->md_type != EFI_MD_TYPE_FREE)
continue;
/*
@ -651,12 +649,12 @@ ia64_init(void)
*/
if (pfn0 >= ia64_btop(0x100000000UL)) {
printf("Skipping memory chunk start 0x%lx\n",
mdp->PhysicalStart);
md->md_phys);
continue;
}
if (pfn1 >= ia64_btop(0x100000000UL)) {
printf("Skipping memory chunk end 0x%lx\n",
mdp->PhysicalStart + mdp->NumberOfPages * 4096);
md->md_phys + md->md_pages * 4096);
continue;
}
@ -672,7 +670,7 @@ ia64_init(void)
* within the segment.
*/
#ifdef DEBUG_MD
printf("Descriptor %d contains kernel\n", i);
printf("Descriptor %p contains kernel\n", mp);
#endif
if (pfn0 < kernstartpfn) {
/*

21
sys/ia64/ia64/sal.c
View File

@ -22,16 +22,18 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <vm/vm.h>
#include <vm/vm_kern.h>
#include <machine/efi.h>
#include <machine/md_var.h>
#include <machine/sal.h>
#include <machine/smp.h>
@ -49,6 +51,9 @@ static sal_entry_t fake_sal;
extern u_int64_t ia64_pal_entry;
sal_entry_t *ia64_sal_entry = fake_sal;
static struct uuid sal_table = EFI_TABLE_SAL;
static struct sal_system_table *sal_systbl;
static struct ia64_sal_result
fake_sal(u_int64_t a1, u_int64_t a2, u_int64_t a3, u_int64_t a4,
u_int64_t a5, u_int64_t a6, u_int64_t a7, u_int64_t a8)
@ -77,7 +82,7 @@ setup_ipi_vectors(int ceil)
}
void
ia64_sal_init(struct sal_system_table *saltab)
ia64_sal_init(void)
{
static int sizes[6] = {
48, 32, 16, 32, 16, 16
@ -85,13 +90,17 @@ ia64_sal_init(struct sal_system_table *saltab)
u_int8_t *p;
int i;
if (memcmp(saltab->sal_signature, SAL_SIGNATURE, 4)) {
sal_systbl = efi_get_table(&sal_table);
if (sal_systbl == NULL)
return;
if (memcmp(sal_systbl->sal_signature, SAL_SIGNATURE, 4)) {
printf("Bad signature for SAL System Table\n");
return;
}
p = (u_int8_t *) (saltab + 1);
for (i = 0; i < saltab->sal_entry_count; i++) {
p = (u_int8_t *) (sal_systbl + 1);
for (i = 0; i < sal_systbl->sal_entry_count; i++) {
switch (*p) {
case 0: {
struct sal_entrypoint_descriptor *dp;

165
sys/ia64/include/efi.h
View File

@ -1,44 +1,163 @@
/*-
* Copyright (c) 2001 Doug Rabson
/*
* Copyright (c) 2004 Marcel Moolenaar
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
* $FreeBSD$
*/
#ifndef _MACHINE_EFI_H_
#define _MACHINE_EFI_H_
#include <boot/efi/include/ia64/efibind.h>
#include <boot/efi/include/efidef.h>
#include <boot/efi/include/efierr.h>
#include <boot/efi/include/efidevp.h>
#include <boot/efi/include/eficon.h>
#include <boot/efi/include/efiapi.h>
#include <sys/uuid.h>
extern EFI_SYSTEM_TABLE *ia64_efi_systab;
extern EFI_RUNTIME_SERVICES *ia64_efi_runtime;
#define EFI_PAGE_SHIFT 12
#define EFI_PAGE_SIZE (1 << EFI_PAGE_SHIFT)
#define EFI_PAGE_MASK (EFI_PAGE_SIZE - 1)
extern void ia64_efi_init(void);
#define EFI_TABLE_ACPI20 \
{0x8868e871,0xe4f1,0x11d3,0xbc,0x22,{0x00,0x80,0xc7,0x3c,0x88,0x81}}
#define EFI_TABLE_SAL \
{0xeb9d2d32,0x2d88,0x11d3,0x9a,0x16,{0x00,0x90,0x27,0x3f,0xc1,0x4d}}
enum efi_reset {
EFI_RESET_COLD,
EFI_RESET_WARM
};
typedef uint16_t efi_char;
typedef unsigned long efi_status;
struct efi_cfgtbl {
struct uuid ct_uuid;
uint64_t ct_data;
};
struct efi_md {
uint32_t md_type;
#define EFI_MD_TYPE_NULL 0
#define EFI_MD_TYPE_CODE 1 /* Loader text. */
#define EFI_MD_TYPE_DATA 2 /* Loader data. */
#define EFI_MD_TYPE_BS_CODE 3 /* Boot services text. */
#define EFI_MD_TYPE_BS_DATA 4 /* Boot services data. */
#define EFI_MD_TYPE_RT_CODE 5 /* Runtime services text. */
#define EFI_MD_TYPE_RT_DATA 6 /* Runtime services data. */
#define EFI_MD_TYPE_FREE 7 /* Unused/free memory. */
#define EFI_MD_TYPE_BAD 8 /* Bad memory */
#define EFI_MD_TYPE_RECLAIM 9 /* ACPI reclaimable memory. */
#define EFI_MD_TYPE_FIRMWARE 10 /* ACPI NV memory */
#define EFI_MD_TYPE_IOMEM 11 /* Memory-mapped I/O. */
#define EFI_MD_TYPE_IOPORT 12 /* I/O port space. */
#define EFI_MD_TYPE_PALCODE 13 /* PAL */
uint32_t __pad;
uint64_t md_phys;
void *md_virt;
uint64_t md_pages;
uint64_t md_attr;
#define EFI_MD_ATTR_UC 0x0000000000000001UL
#define EFI_MD_ATTR_WC 0x0000000000000002UL
#define EFI_MD_ATTR_WT 0x0000000000000004UL
#define EFI_MD_ATTR_WB 0x0000000000000008UL
#define EFI_MD_ATTR_UCE 0x0000000000000010UL
#define EFI_MD_ATTR_WP 0x0000000000001000UL
#define EFI_MD_ATTR_RP 0x0000000000002000UL
#define EFI_MD_ATTR_XP 0x0000000000004000UL
#define EFI_MD_ATTR_RT 0x8000000000000000UL
};
struct efi_tm {
uint16_t tm_year; /* 1998 - 20XX */
uint8_t tm_mon; /* 1 - 12 */
uint8_t tm_mday; /* 1 - 31 */
uint8_t tm_hour; /* 0 - 23 */
uint8_t tm_min; /* 0 - 59 */
uint8_t tm_sec; /* 0 - 59 */
uint8_t __pad1;
uint32_t tm_nsec; /* 0 - 999,999,999 */
int16_t tm_tz; /* -1440 to 1440 or 2047 */
uint8_t tm_dst;
uint8_t __pad2;
};
struct efi_tmcap {
uint32_t tc_res; /* 1e-6 parts per million */
uint32_t tc_prec; /* hertz */
uint8_t tc_stz; /* Set clears sub-second time */
};
struct efi_tblhdr {
uint64_t th_sig;
uint32_t th_rev;
uint32_t th_hdrsz;
uint32_t th_crc32;
uint32_t __res;
};
struct efi_rt {
struct efi_tblhdr rt_hdr;
efi_status (*rt_gettime)(struct efi_tm *, struct efi_tmcap *);
efi_status (*rt_settime)(struct efi_tm *);
efi_status (*rt_getwaketime)(uint8_t *, uint8_t *,
struct efi_tm *);
efi_status (*rt_setwaketime)(uint8_t, struct efi_tm *);
efi_status (*rt_setvirtual)(u_long, u_long, uint32_t,
struct efi_md *);
efi_status (*rt_cvtptr)(u_long, void **);
efi_status (*rt_getvar)(efi_char *, struct uuid *, uint32_t *,
u_long *, void *);
efi_status (*rt_scanvar)(u_long *, efi_char *, struct uuid *);
efi_status (*rt_setvar)(efi_char *, struct uuid *, uint32_t,
u_long, void *);
efi_status (*rt_gethicnt)(uint32_t *);
efi_status (*rt_reset)(enum efi_reset, efi_status, u_long,
efi_char *);
};
struct efi_systbl {
struct efi_tblhdr st_hdr;
#define EFI_SYSTBL_SIG 0x5453595320494249UL
efi_char *st_fwvendor;
uint32_t st_fwrev;
uint32_t __pad;
void *st_cin;
void *st_cinif;
void *st_cout;
void *st_coutif;
void *st_cerr;
void *st_cerrif;
uint64_t st_rt;
void *st_bs;
u_long st_entries;
uint64_t st_cfgtbl;
};
void efi_boot_finish(void);
int efi_boot_minimal(uint64_t);
void *efi_get_table(struct uuid *);
void efi_get_time(struct efi_tm *);
struct efi_md *efi_md_first(void);
struct efi_md *efi_md_next(struct efi_md *);
void efi_reset_system(void);
efi_status efi_set_time(struct efi_tm *);
#endif /* _MACHINE_EFI_H_ */

2
sys/ia64/include/sal.h
View File

@ -137,6 +137,6 @@ typedef struct ia64_sal_result sal_entry_t
extern sal_entry_t *ia64_sal_entry;
extern void ia64_sal_init(struct sal_system_table *saltab);
extern void ia64_sal_init(void);
#endif /* _MACHINE_SAL_H_ */