删除gnuefi的示例代码 (#11)

apps/AllocPages.c

@@ -1,184 +0,0 @@
-
-/*
- * Copyright (C) 2013 Jerry Hoemann <jerry.hoemann@hp.com>
- *
- *
- * Application to allocate memory at EFI.  Syntax of command
- * mimics the EFI Boot Service "AllocatePages."
- *
- * See UEFI spec 2.3, Section 6.2.
- *
- *
-
-
-
-
-FS1:\> memmap
-Type      Start            End              #pages             Attributes
-BS_Code   0000000000000000-0000000000000FFF 0000000000000001 000000000000000F
-Available 0000000000001000-000000000008DFFF 000000000000008D 000000000000000F
-Reserved  000000000008E000-000000000008FFFF 0000000000000002 000000000000000F
-Available 0000000000090000-000000000009FFFF 0000000000000010 000000000000000F
-Available 0000000000100000-000000000FFFFFFF 000000000000FF00 000000000000000F
-BS_Code   0000000010000000-0000000010061FFF 0000000000000062 000000000000000F
-Available 0000000010062000-000000005CDFFFFF 000000000004CD9E 000000000000000F
-ACPI_NVS  000000005CE00000-000000005DDFFFFF 0000000000001000 000000000000000F
-BS_Data   000000005DE00000-000000005DFFFFFF 0000000000000200 000000000000000F
-Available 000000005E000000-000000005EF1CFFF 0000000000000F1D 000000000000000F
-BS_Data   000000005EF1D000-00000000709FBFFF 0000000000011ADF 000000000000000F
-Available 00000000709FC000-00000000710E3FFF 00000000000006E8 000000000000000F
-LoaderCode 00000000710E4000-00000000711FEFFF 000000000000011B 000000000000000F
-Available 00000000711FF000-0000000071901FFF 0000000000000703 000000000000000F
-BS_Code   0000000071902000-00000000721FEFFF 00000000000008FD 000000000000000F
-
-
-Example to allocat 5 pages type BootCode at address 20000000 (hex)
-
-
-FS1:\> AllocPages.efi 2 3 5 20000000
-AllocatePage: __AllocType__ __MemType__ __NumPages__ [__Addr__]
-__AllocType__ {0,1,2} -- Any, MaxAddr, Addr
-__MemType__   {0..13}, Reserved ==0, LCode==1, LData==2, BSCode==3, BSData==4, ...
-__NumPages__  {0..F000000}
-[__Addr__]     0... 3FFFFFFFFFFF
-All numbers in hex no leading 0x
-
-AllocatPage(2,3,5,20000000)
-
-
-Example to allocat 5 pages type BootCode at address 30000000 (hex)
-
-
-FS1:\> AllocPages.efi 2 3 5 30000000
-AllocatePage: __AllocType__ __MemType__ __NumPages__ [__Addr__]
-__AllocType__ {0,1,2} -- Any, MaxAddr, Addr
-__MemType__   {0..13}, Reserved ==0, LCode==1, LData==2, BSCode==3, BSData==4, ...
-__NumPages__  {0..F000000}
-[__Addr__]     0... 3FFFFFFFFFFF
-All numbers in hex no leading 0x
-
-
-
-FS1:\> memmap
-Type      Start            End              #pages             Attributes
-BS_Code   0000000000000000-0000000000000FFF 0000000000000001 000000000000000F
-Available 0000000000001000-000000000008DFFF 000000000000008D 000000000000000F
-Reserved  000000000008E000-000000000008FFFF 0000000000000002 000000000000000F
-Available 0000000000090000-000000000009FFFF 0000000000000010 000000000000000F
-Available 0000000000100000-000000000FFFFFFF 000000000000FF00 000000000000000F
-BS_Code   0000000010000000-0000000010061FFF 0000000000000062 000000000000000F
-Available 0000000010062000-000000001FFFFFFF 000000000000FF9E 000000000000000F
-BS_Code   0000000020000000-0000000020004FFF 0000000000000005 000000000000000F
-Available 0000000020005000-000000002FFFFFFF 000000000000FFFB 000000000000000F
-BS_Code   0000000030000000-0000000030004FFF 0000000000000005 000000000000000F
-Available 0000000030005000-000000005CDFFFFF 000000000002CDFB 000000000000000F
-ACPI_NVS  000000005CE00000-000000005DDFFFFF 0000000000001000 000000000000000F
-BS_Data   000000005DE00000-000000005DFFFFFF 0000000000000200 000000000000000F
-Available 000000005E000000-000000005EF1CFFF 0000000000000F1D 000000000000000F
-BS_Data   000000005EF1D000-00000000709FBFFF 0000000000011ADF 000000000000000F
-Available 00000000709FC000-00000000710E3FFF 00000000000006E8 000000000000000F
-LoaderCode 00000000710E4000-00000000711FEFFF 000000000000011B 000000000000000F
-Available 00000000711FF000-0000000071901FFF 0000000000000703 000000000000000F
-BS_Code   0000000071902000-00000000721FEFFF 00000000000008FD 000000000000000F
-
-
-
-
-
- */
-
-#include <efi.h>
-#include <efilib.h>
-
-
-#define MAX_NUM_PAGES 0x000000000F000000
-#define MAX_ADDR ((1ULL << 46) - 1)
-
-
-#ifdef DEBUG
-#undef DEBUG
-#endif
-#define DEBUG 0
-
-
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-
-	EFI_STATUS efi_status;
-	CHAR16 **argv;
-	INTN argc;
-	INTN err = 0;
-#if DEBUG
-	INTN c = 0;
-#endif
-	INTN AllocType = -1;
-	INTN MemType = -1;
-	INTN NumPages = -1;
-	EFI_PHYSICAL_ADDRESS Addr = 0;
-
-	InitializeLib(image, systab);
-
-	Print(L"AllocatePage: __AllocType__ __MemType__ __NumPages__ [__Addr__]\n");
-	Print(L"__AllocType__ {0,1,2} -- Any, MaxAddr, Addr\n"); 
-	Print(L"__MemType__   {0..13}, Reserved ==0, LCode==1, LData==2, BSCode==3, BSData==4, ...\n");
-	Print(L"__NumPages__  {0..%x}\n", MAX_NUM_PAGES);
-	Print(L"[__Addr__]     0... %llx\n", MAX_ADDR);
-	Print(L"All numbers in hex no leading 0x\n");
-	Print(L"\n");
-
-#if DEBUG
-	Print(L"Now get argc/argv\n");
-#endif
-	argc = GetShellArgcArgv(image, &argv);
-#if DEBUG
-	Print(L"argc = %d\n", argc);
-#endif
-
-#if DEBUG
-	for (c = 0;  c < argc;  c++ ) {
-		Print(L"argv[%d] = <%s>\n", c, argv[c]);
-	}
-#endif
-	if ( (argc < 4) || (argc > 5) ) {
-		Print(L"Wrong argument count\n");
-		return EFI_SUCCESS;
-	}
-
-	AllocType = xtoi(argv[1]);
-	MemType   = xtoi(argv[2]);
-	NumPages  = xtoi(argv[3]);
-	if ( argc == 5 ) Addr = xtoi(argv[4]);
-
-	if ( (AllocType < 0) || (AllocType > 2)) {
-		Print(L"Invalid AllocType\n");
-		err++;
-	}
-	if ( (MemType < 0) || (MemType > 13) ) {
-		Print(L"Invalid MemType\n");
-		err++;
-	}
-	if ( (NumPages < 0) || (NumPages > MAX_NUM_PAGES) ) {
-		Print(L"Inavlid NumPages\n");
-		err++;
-	}
-	if ( Addr > MAX_ADDR ) {
-		Print(L"Inavlid Address\n");
-		err++;
-	}
-	if ( err ) {
-		return EFI_INVALID_PARAMETER;
-	}
-
-	Print(L"AllocatPage(%d,%d,%d,%lx)\n", AllocType, MemType, NumPages, Addr);
-
-	efi_status = uefi_call_wrapper(BS->AllocatePages, 4, AllocType, MemType, NumPages, &Addr);
-
-	if ( EFI_ERROR(efi_status) ) {
-		Print(L"Allocate Pages Failed: %d\n", efi_status);
-		return efi_status;
-	}
-
-	return EFI_SUCCESS;
-}

apps/FreePages.c

@@ -1,145 +0,0 @@
-
-
-/*
- * Copyright (C) 2013 Jerry Hoemann <jerry.hoemann@hp.com>
- *
- * Application to allocate memory at EFI.  Syntax of command
- * mimics the EFI Boot Service "FreePages."
- *
- * See UEFI spec 2.3, Section 6.2.
- *
-
-Example freeing a 5 page BS_Code setment at address: 0000000020000000 (hex)
-
-
-FS1:\> memmap
-Type      Start            End              #pages             Attributes
-BS_Code   0000000000000000-0000000000000FFF 0000000000000001 000000000000000F
-Available 0000000000001000-000000000008DFFF 000000000000008D 000000000000000F
-Reserved  000000000008E000-000000000008FFFF 0000000000000002 000000000000000F
-Available 0000000000090000-000000000009FFFF 0000000000000010 000000000000000F
-Available 0000000000100000-000000000FFFFFFF 000000000000FF00 000000000000000F
-BS_Code   0000000010000000-0000000010061FFF 0000000000000062 000000000000000F
-Available 0000000010062000-000000001FFFFFFF 000000000000FF9E 000000000000000F
-BS_Code   0000000020000000-0000000020004FFF 0000000000000005 000000000000000F
-Available 0000000020005000-000000005DDFFFFF 000000000003DDFB 000000000000000F
-BS_Data   000000005DE00000-000000005DFFFFFF 0000000000000200 000000000000000F
-Available 000000005E000000-000000006DE7CFFF 000000000000FE7D 000000000000000F
-ACPI_NVS  000000006DE7D000-000000006EE7CFFF 0000000000001000 000000000000000F
-BS_Data   000000006EE7D000-00000000709FBFFF 0000000000001B7F 000000000000000F
-Available 00000000709FC000-00000000710E3FFF 00000000000006E8 000000000000000F
-
-
-FS1:\> FreePages 0000000020000000 5
-FreePages: __PhysAddr__ __PgCnt__
-__PhysAddr__   0... 3FFFFFFFFFFF
-__PgCnt__     [0..F000000]
-All numbers hex w/ no leading 0x
-
-FreePages(20000000,5)
-
-
-
-FS1:\> memmap
-Type      Start            End              #pages             Attributes
-BS_Code   0000000000000000-0000000000000FFF 0000000000000001 000000000000000F
-Available 0000000000001000-000000000008DFFF 000000000000008D 000000000000000F
-Reserved  000000000008E000-000000000008FFFF 0000000000000002 000000000000000F
-Available 0000000000090000-000000000009FFFF 0000000000000010 000000000000000F
-Available 0000000000100000-000000000FFFFFFF 000000000000FF00 000000000000000F
-BS_Code   0000000010000000-0000000010061FFF 0000000000000062 000000000000000F
-Available 0000000010062000-000000005DDFFFFF 000000000004DD9E 000000000000000F
-BS_Data   000000005DE00000-000000005DFFFFFF 0000000000000200 000000000000000F
-Available 000000005E000000-000000006DE7CFFF 000000000000FE7D 000000000000000F
-ACPI_NVS  000000006DE7D000-000000006EE7CFFF 0000000000001000 000000000000000F
-BS_Data   000000006EE7D000-00000000709FBFFF 0000000000001B7F 000000000000000F
-Available 00000000709FC000-00000000710E3FFF 00000000000006E8 000000000000000F
-
-
- */
-
-#include <efi.h>
-#include <efilib.h>
-
-/*
- * FreePages:  __PhysAddr__ __PgCnt__
- *
- */
-
-#define MAX_NUM_PAGES 0x000000000F000000
-
-#define MAX_ADDR ((1ULL << 46) - 1)
-
-#ifdef DEBUG
-#undef DEBUG
-#endif
-#define DEBUG 0
-
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-
-	EFI_STATUS efi_status;
-	CHAR16 **argv;
-	INTN argc = 0;
-#if DEBUG
-	INTN c = 0;
-#endif
-	INTN err = 0;
-
-	INTN PgCnt = -1;
-	EFI_PHYSICAL_ADDRESS PhysAddr = 0;
-
-	InitializeLib(image, systab);
-
-	Print(L"FreePages: __PhysAddr__ __PgCnt__\n");
-	Print(L"__PhysAddr__   0... %llx\n", MAX_ADDR);
-	Print(L"__PgCnt__     [0..%lx]\n", MAX_NUM_PAGES);
-	Print(L"All numbers hex w/ no leading 0x\n");
-	Print(L"\n");
-
-#if DEBUG
-	Print(L"Now parse argc/argv\n");
-#endif
-	argc = GetShellArgcArgv(image, &argv);
-#if DEBUG
-	Print(L"argc = %d\n", argc);
-#endif
-
-#if DEBUG
-	for (c = 0;  c < argc;  c++ ) {
-		Print(L"argv[%d] = <%s>\n", c, argv[c]);
-	}
-#endif
-	if (argc != 3) {
-		Print(L"Invalid argument count\n");
-		return EFI_SUCCESS;
-	}
-
-	PhysAddr = xtoi(argv[1]);
-	PgCnt	 = xtoi(argv[2]);
-
-	if ( (PgCnt < 0) || (PgCnt > MAX_NUM_PAGES) ) {
-		Print(L"Inavlid PgCnt\n");
-		err++;
-	}
-	if ( PhysAddr > MAX_ADDR ) {
-		Print(L"Inavlid Address\n");
-		err++;
-	}
-	if ( err ) {
-		return EFI_SUCCESS;
-	}
-
-	Print(L"FreePages(%lx,%d)\n", PhysAddr, PgCnt);
-
-	efi_status = uefi_call_wrapper(BS->FreePages, 2, PhysAddr, PgCnt);
-
-	if ( EFI_ERROR(efi_status) ) {
-		Print(L"Free Pages Failed: %d\n", efi_status);
-		return efi_status;
-	}
-
-	return EFI_SUCCESS;
-}

apps/Makefile

@@ -59,12 +59,6 @@ LOADLIBES	+= -lefi -lgnuefi
 LOADLIBES	+= $(LIBGCC)
 LOADLIBES	+= -T $(LDSCRIPT)
 
-TARGET_APPS = t.efi t2.efi t3.efi t4.efi t5.efi t6.efi \
-	      printenv.efi t7.efi t8.efi tcc.efi modelist.efi \
-	      route80h.efi drv0_use.efi AllocPages.efi exit.efi \
-	      FreePages.efi setjmp.efi debughook.efi debughook.efi.debug \
-	      bltgrid.efi lfbgrid.efi setdbg.efi unsetdbg.efi \
-	      ctors_test.efi ctors_dtors_priority_test.efi
 TARGET_BSDRIVERS = drv0.efi
 TARGET_RTDRIVERS =
 

apps/bltgrid.c

@@ -1,133 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-extern EFI_GUID GraphicsOutputProtocol;
-
-static void
-fill_boxes(UINT32 *PixelBuffer, UINT32 Width, UINT32 Height)
-{
-	UINT32 y, x = 0;
-	/*
-	 * This assums BGRR, but it doesn't really matter; we pick red and
-	 * green so it'll just be blue/green if the pixel format is backwards.
-	 */
-	EFI_GRAPHICS_OUTPUT_BLT_PIXEL Red = {0, 0, 0xff, 0},
-				      Green = {0, 0xff, 0, 0},
-				      *Color;
-
-	for (y = 0; y < Height; y++) {
-		Color = ((y / 32) % 2 == 0) ? &Red : &Green;
-		for (x = 0; x < Width; x++) {
-			if (x % 32 == 0 && x != 0)
-				Color = (Color == &Red) ? &Green : &Red;
-			PixelBuffer[y * Width + x] = *(UINT32 *)Color;
-		}
-	}
-}
-
-static void
-draw_boxes(EFI_GRAPHICS_OUTPUT_PROTOCOL *gop)
-{
-	int i, imax;
-	EFI_STATUS rc;
-	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
-	UINTN NumPixels;
-	UINT32 *PixelBuffer;
-	UINT32 BufferSize;
-
-	if (gop->Mode) {
-		imax = gop->Mode->MaxMode;
-	} else {
-		Print(L"gop->Mode is NULL\n");
-		return;
-	}
-
-	for (i = 0; i < imax; i++) {
-		UINTN SizeOfInfo;
-		rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i, &SizeOfInfo,
-					&info);
-		if (rc == EFI_NOT_STARTED) {
-			Print(L"gop->QueryMode() returned %r\n", rc);
-			Print(L"Trying to start GOP with SetMode().\n");
-			rc = uefi_call_wrapper(gop->SetMode, 2, gop,
-				gop->Mode ? gop->Mode->Mode : 0);
-			rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i,
-				&SizeOfInfo, &info);
-		}
-
-		if (EFI_ERROR(rc)) {
-			Print(L"%d: Bad response from QueryMode: %r (%d)\n",
-			      i, rc, rc);
-			continue;
-		}
-
-		if (CompareMem(info, gop->Mode->Info, sizeof (*info)))
-			continue;
-
-		NumPixels = (UINTN)info->VerticalResolution
-                            * (UINTN)info->HorizontalResolution;
-		BufferSize = NumPixels * sizeof(UINT32);
-
-		PixelBuffer = AllocatePool(BufferSize);
-		if (!PixelBuffer) {
-			Print(L"Allocation of 0x%08lx bytes failed.\n",
-			      sizeof(UINT32) * NumPixels);
-			return;
-		}
-
-		fill_boxes(PixelBuffer,
-			   info->HorizontalResolution, info->VerticalResolution);
-
-		uefi_call_wrapper(gop->Blt, 10, gop,
-				  (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)PixelBuffer,
-				  EfiBltBufferToVideo,
-				  0, 0, 0, 0,
-				  info->HorizontalResolution,
-				  info->VerticalResolution,
-				  0);
-		FreePool(PixelBuffer);
-		return;
-	}
-	Print(L"Never found the active video mode?\n");
-}
-
-static EFI_STATUS
-SetWatchdog(UINTN seconds)
-{
-	EFI_STATUS rc;
-	rc = uefi_call_wrapper(BS->SetWatchdogTimer, 4, seconds, 0x1ffff,
-				0, NULL);
-	if (EFI_ERROR(rc)) {
-		CHAR16 Buffer[64];
-		StatusToString(Buffer, rc);
-		Print(L"Bad response from QueryMode: %s (%d)\n", Buffer, rc);
-	}
-	return rc;
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS rc;
-	EFI_GRAPHICS_OUTPUT_PROTOCOL *gop;
-
-	InitializeLib(image_handle, systab);
-
-	SetWatchdog(10);
-
-	rc = LibLocateProtocol(&GraphicsOutputProtocol, (void **)&gop);
-	if (EFI_ERROR(rc)) {
-		Print(L"Could not locate GOP: %r\n", rc);
-		return rc;
-	}
-
-	if (!gop) {
-		Print(L"LocateProtocol(GOP, &gop) returned %r but GOP is NULL\n", rc);
-		return EFI_UNSUPPORTED;
-	}
-
-	draw_boxes(gop);
-
-	SetWatchdog(0);
-	return EFI_SUCCESS;
-}

apps/ctors_dtors_priority_test.c

@@ -1,29 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-// 101 in init_array, 65434 in ctors
-static void __attribute__((constructor(101))) EFI_NO_TAIL_CALL ctors101() {
-    Print(L"1) ctor with lower numbered priority \r\n");
-}
-
-// 65434 in init_array, 101 in ctors
-static void __attribute__((constructor(65434))) EFI_NO_TAIL_CALL ctors65434() {
-    Print(L"2) ctor with higher numbered priority \r\n");
-}
-
-// 101 in fini_array, 65434 in dtors
-static void __attribute__((destructor(101))) EFI_NO_TAIL_CALL dtors101() {
-    Print(L"4) dtor with lower numbered priority \r\n");
-}
-
-// 65434 in fini_array, 101 in dtors
-static void __attribute__((destructor(65434))) EFI_NO_TAIL_CALL dtors65434() {
-    Print(L"3) dtor with higher numbered priority \r\n");
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image EFI_UNUSED, EFI_SYSTEM_TABLE *systab EFI_UNUSED)
-{
-    Print(L"Main function \r\n");
-    return EFI_SUCCESS;
-}

apps/ctors_fns.c

@@ -1,26 +0,0 @@
-/*
- * ctors.c
- * Copyright 2019 Peter Jones <pjones@redhat.com>
- *
- */
-
-#include <efi.h>
-#include <efilib.h>
-
-int constructed_value = 0;
-
-static void __attribute__((__constructor__)) EFI_NO_TAIL_CALL ctor(void)
-{
-	Print(L"%a:%d:%a() constructed_value:%d\n", __FILE__, __LINE__, __func__, constructed_value);
-	constructed_value = 1;
-	Print(L"%a:%d:%a() constructed_value:%d\n", __FILE__, __LINE__, __func__, constructed_value);
-}
-
-static void __attribute__((__destructor__)) EFI_NO_TAIL_CALL dtor(void)
-{
-	Print(L"%a:%d:%a() constructed_value:%d\n", __FILE__, __LINE__, __func__, constructed_value);
-	constructed_value = 0;
-	Print(L"%a:%d:%a() constructed_value:%d\n", __FILE__, __LINE__, __func__, constructed_value);
-}
-
-// vim:fenc=utf-8:tw=75:noet

apps/ctors_test.c

@@ -1,20 +0,0 @@
-/*
- * ctors_test.c
- * Copyright 2019 Peter Jones <pjones@redhat.com>
- *
- */
-
-#include <efi.h>
-#include <efilib.h>
-
-extern int constructed_value;
-
-EFI_STATUS
-efi_main (EFI_HANDLE image EFI_UNUSED, EFI_SYSTEM_TABLE *systab EFI_UNUSED)
-{
-	Print(L"%a:%d:%a() constructed_value:%d\n", __FILE__, __LINE__, __func__, constructed_value);
-
-	return EFI_SUCCESS;
-}
-
-// vim:fenc=utf-8:tw=75:noet

apps/debughook.c

@@ -1,91 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-GetVariableAttr(CHAR16 *var, UINT8 **data, UINTN *len, EFI_GUID owner,
-		  UINT32 *attributes)
-{
-	EFI_STATUS efi_status;
-
-	*len = 0;
-
-	efi_status = uefi_call_wrapper(RT->GetVariable, 5, var, &owner,
-				       NULL, len, NULL);
-	if (efi_status != EFI_BUFFER_TOO_SMALL)
-		return efi_status;
-
-	*data = AllocateZeroPool(*len);
-	if (!*data)
-		return EFI_OUT_OF_RESOURCES;
-
-	efi_status = uefi_call_wrapper(RT->GetVariable, 5, var, &owner,
-				       attributes, len, *data);
-
-	if (efi_status != EFI_SUCCESS) {
-		FreePool(*data);
-		*data = NULL;
-	}
-	return efi_status;
-}
-
-EFI_STATUS
-GetVariable(CHAR16 *var, UINT8 **data, UINTN *len, EFI_GUID owner)
-{
-	return GetVariableAttr(var, data, len, owner, NULL);
-}
-
-EFI_GUID DUMMY_GUID =
-{0x55aad538, 0x8f82, 0x4e2a, {0xa4,0xf0,0xbe, 0x59, 0x13, 0xb6, 0x5f, 0x1e}};
-
-static EFI_OPTNONE void
-DebugHook(void)
-{
-	EFI_GUID guid = DUMMY_GUID;
-	UINT8 *data = NULL;
-	UINTN dataSize = 0;
-	EFI_STATUS efi_status;
-	register volatile unsigned long long x = 0;
-	extern char _text, _data;
-
-	if (x)
-		return;
-
-	efi_status = GetVariable(L"DUMMY_DEBUG", &data, &dataSize, guid);
-	if (EFI_ERROR(efi_status)) {
-		return;
-	}
-
-	Print(L"add-symbol-file /usr/lib/debug/boot/efi/debughook.debug "
-	      L"0x%08x -s .data 0x%08x\n", &_text, &_data);
-
-	Print(L"Pausing for debugger attachment.\n");
-	Print(L"To disable this, remove the EFI variable DUMMY_DEBUG-%g .\n",
-	      &guid);
-	x = 1;
-	while (x++) {
-		/* Make this so it can't /totally/ DoS us. */
-#if defined(__x86_64__) || defined(__i386__) || defined(__i686__)
-		if (x > 4294967294ULL)
-			break;
-		__asm__ __volatile__("pause");
-#elif defined(__aarch64__)
-		if (x > 1000)
-			break;
-		__asm__ __volatile__("wfi");
-#else
-		if (x > 12000)
-			break;
-		uefi_call_wrapper(BS->Stall, 1, 5000);
-#endif
-	}
-	x = 1;
-}
-
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	InitializeLib(image, systab);
-	DebugHook();
-	return EFI_SUCCESS;
-}

apps/drv0.c

@@ -1,191 +0,0 @@
-/*
- * Copyright (C) 2013 David Decotigny <decot@googlers.com>
- *
- * Sample EFI shell session, together with drv0_use.efi:
- *
- *  # Loading first instance:
- *
- *    fs0:\> load drv0.efi
- *    Driver instance loaded successfully.
- *    load: Image fs0:\drv0.efi loaded at 2FD7C000 - Success
- *
- *  # Testing 1st instance:
- *
- *    fs0:\> drv0_use.efi
- *    Playing with driver instance 0...
- *    Hello Sample UEFI Driver!
- *    Hello was called 1 time(s).
- *
- *    fs0:\> drv0_use.efi
- *    Playing with driver instance 0...
- *    Hello Sample UEFI Driver!
- *    Hello was called 2 time(s).
- *
- *  # Loading another instance:
- *
- *    fs0:\> load drv0.efi
- *    Driver instance loaded successfully.
- *    load: Image fs0:\drv0.efi loaded at 2FD6D000 - Success
- *
- *  # Using both instances:
- *
- *    fs0:\> drv0_use.efi
- *    Playing with driver instance 0...
- *    Hello Sample UEFI Driver!
- *    Hello was called 3 time(s).
- *    Playing with driver instance 1...
- *    Hello Sample UEFI Driver!
- *    Hello was called 1 time(s).
- *
- *    fs0:\> drv0_use.efi
- *    Playing with driver instance 0...
- *    Hello Sample UEFI Driver!
- *    Hello was called 4 time(s).
- *    Playing with driver instance 1...
- *    Hello Sample UEFI Driver!
- *    Hello was called 2 time(s).
- *
- *  # Removing 1st instance:
- *
- *    fs0:\> dh
- *    Handle dump
- *      1: Image(DxeCore)
- *    [...]
- *     79: Image(\/drv0.efi) ImageDevPath (..A,0x800,0x17F7DF)/\/drv0.efi)
- *     7A: Image(\/drv0.efi) ImageDevPath (..A,0x800,0x17F7DF)/\/drv0.efi)
- *
- *    fs0:\> unload 79
- *     79: Image(\/drv0.efi) ImageDevPath (..A,0x800,0x17F7DF)/\/drv0.efi)
- *    Unload driver image (y/n)? y
- *    Driver instance unloaded.
- *    unload: Success
- *
- *  # Only 2nd instance remaining:
- *
- *    fs0:\> drv0_use.efi
- *    Playing with driver instance 0...
- *    Hello Sample UEFI Driver!
- *    Hello was called 3 time(s).
- *
- *  # Removing 2nd/last instance:
- *
- *    fs0:\> dh
- *    Handle dump
- *      1: Image(DxeCore)
- *    [...]
- *     79: Image(\/drv0.efi) ImageDevPath (..A,0x800,0x17F7DF)/\/drv0.efi)
- *
- *    fs0:\> unload 79
- *     79: Image(\/drv0.efi) ImageDevPath (..A,0x800,0x17F7DF)/\/drv0.efi)
- *    Unload driver image (y/n)? y
- *    Driver instance unloaded.
- *    unload: Success
- *
- *  # Expect error: no other drv0 instance left
- *
- *    fs0:\> drv0_use.efi
- *    Error looking up handles for proto: 14
- */
-
-#include <efi.h>
-#include <efilib.h>
-#include "drv0.h"
-
-
-static const EFI_GUID GnuEfiAppsDrv0ProtocolGuid
-  = GNU_EFI_APPS_DRV0_PROTOCOL_GUID;
-
-static struct {
-  GNU_EFI_APPS_DRV0_PROTOCOL Proto;
-  UINTN Counter;
-} InternalGnuEfiAppsDrv0ProtocolData;
-
-
-static
-EFI_STATUS
-EFI_FUNCTION
-Drv0SayHello(
-    IN const CHAR16 *HelloWho
-    )
-{
-  if (! HelloWho)
-    return EFI_INVALID_PARAMETER;
-
-  Print(L"Hello %s!\n", HelloWho);
-  InternalGnuEfiAppsDrv0ProtocolData.Counter ++;
-  return EFI_SUCCESS;
-}
-
-
-static
-EFI_STATUS
-EFI_FUNCTION
-Drv0GetNumberOfHello(
-    OUT UINTN *NumberOfHello
-    )
-{
-  if (! NumberOfHello)
-    return EFI_INVALID_PARAMETER;
-
-  *NumberOfHello = InternalGnuEfiAppsDrv0ProtocolData.Counter;
-  return EFI_SUCCESS;
-}
-
-
-static
-EFI_STATUS
-EFI_FUNCTION
-Drv0Unload(IN EFI_HANDLE ImageHandle)
-{
-  LibUninstallProtocolInterfaces(ImageHandle,
-                                 &GnuEfiAppsDrv0ProtocolGuid,
-                                 &InternalGnuEfiAppsDrv0ProtocolData.Proto,
-                                 NULL);
-  Print(L"Driver instance unloaded.\n", ImageHandle);
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SysTab)
-{
-  EFI_STATUS Status;
-  EFI_LOADED_IMAGE *LoadedImage = NULL;
-
-  InitializeLib(ImageHandle, SysTab);
-
-  /* Initialize global protocol definition + data */
-  InternalGnuEfiAppsDrv0ProtocolData.Proto.SayHello
-      = (GNU_EFI_APPS_DRV0_SAY_HELLO) Drv0SayHello;
-  InternalGnuEfiAppsDrv0ProtocolData.Proto.GetNumberOfHello
-      = (GNU_EFI_APPS_DRV0_GET_NUMBER_OF_HELLO) Drv0GetNumberOfHello;
-  InternalGnuEfiAppsDrv0ProtocolData.Counter = 0;
-
-  /* Grab handle to this image: we'll attach our proto instance to it */
-  Status = uefi_call_wrapper(BS->OpenProtocol, 6,
-                             ImageHandle, &LoadedImageProtocol,
-                             (void**)&LoadedImage, ImageHandle,
-                             NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
-  if (EFI_ERROR(Status)) {
-    Print(L"Could not open loaded image protocol: %d\n", Status);
-    return Status;
-  }
-
-  /* Attach our proto to the current driver image */
-  Status = LibInstallProtocolInterfaces(
-      &ImageHandle, &GnuEfiAppsDrv0ProtocolGuid,
-      &InternalGnuEfiAppsDrv0ProtocolData.Proto, NULL);
-  if (EFI_ERROR(Status)) {
-    Print(L"Error registering driver instance: %d\n", Status);
-    return Status;
-  }
-
-  /* Register Unload callback, used to unregister current protocol
-   * instance from system */
-  LoadedImage->Unload = (EFI_IMAGE_UNLOAD)Drv0Unload;
-
-  Print(L"Driver instance loaded successfully.\n");
-  return EFI_SUCCESS;  /* at this point, this instance stays resident
-                        * until image is unloaded, eg. with shell's unload,
-                        * ExitBootServices() */
-}

apps/drv0.h

@@ -1,35 +0,0 @@
-#ifndef _GNU_EFI_APPS_DRV0_H_
-#define _GNU_EFI_APPS_DRV0_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* UEFI naming conventions */
-#define GNU_EFI_APPS_DRV0_PROTOCOL_GUID \
-{ 0xe4dcafd0, 0x586c, 0x4b3d, {0x86, 0xe7, 0x28, 0xde, 0x7f, 0xcc, 0x04, 0xb9} }
-
-INTERFACE_DECL(_GNU_EFI_APPS_DRV0_PROTOCOL);
-
-typedef
-EFI_STATUS
-(EFIAPI *GNU_EFI_APPS_DRV0_SAY_HELLO) (
-    IN const CHAR16 *HelloWho
-    );
-
-typedef
-EFI_STATUS
-(EFIAPI *GNU_EFI_APPS_DRV0_GET_NUMBER_OF_HELLO) (
-    OUT UINTN *NumberOfHello
-    );
-
-typedef struct _GNU_EFI_APPS_DRV0_PROTOCOL {
-  GNU_EFI_APPS_DRV0_SAY_HELLO           SayHello;
-  GNU_EFI_APPS_DRV0_GET_NUMBER_OF_HELLO GetNumberOfHello;
-} GNU_EFI_APPS_DRV0_PROTOCOL;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

apps/drv0_use.c

@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2013 David Decotigny <decot@googlers.com>
- *
- * See drv0.c for an example session.
- */
-
-#include <efi.h>
-#include <efilib.h>
-#include "drv0.h"
-
-
-static EFI_GUID GnuEfiAppsDrv0ProtocolGuid
-  = GNU_EFI_APPS_DRV0_PROTOCOL_GUID;
-
-
-static
-EFI_STATUS
-PlayWithGnuEfiAppsDrv0Protocol(IN EFI_HANDLE DrvHandle) {
-  EFI_STATUS Status;
-  GNU_EFI_APPS_DRV0_PROTOCOL *drv = NULL;
-  UINTN NumberOfHello = 0;
-
-  Status = uefi_call_wrapper(BS->OpenProtocol, 6,
-                             DrvHandle,
-                             &GnuEfiAppsDrv0ProtocolGuid,
-                             (void**)&drv,
-                             DrvHandle,
-                             NULL,
-                             EFI_OPEN_PROTOCOL_GET_PROTOCOL);
-  if (EFI_ERROR(Status)) {
-    Print(L"Cannot open proto: %d\n", Status);
-    return Status;
-  }
-
-  Status = uefi_call_wrapper(drv->SayHello, 2, L"Sample UEFI Driver");
-  if (EFI_ERROR(Status)) {
-    Print(L"Cannot call SayHello: %d\n", Status);
-  }
-
-  Status = uefi_call_wrapper(drv->GetNumberOfHello, 2, &NumberOfHello);
-  if (EFI_ERROR(Status)) {
-    Print(L"Cannot call GetNumberOfHello: %d\n", Status);
-  } else {
-    Print(L"Hello was called %d time(s).\n", NumberOfHello);
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-efi_main (EFI_HANDLE Image, EFI_SYSTEM_TABLE *SysTab)
-{
-  EFI_STATUS Status;
-  EFI_HANDLE *Handles = NULL;
-  UINTN i, NoHandles = 0;
-
-  InitializeLib(Image, SysTab);
-
-  Status = LibLocateHandle(ByProtocol, &GnuEfiAppsDrv0ProtocolGuid,
-                           NULL, &NoHandles, &Handles);
-  if (EFI_ERROR(Status)) {
-    Print(L"Error looking up handles for proto: %d\n", Status);
-    return Status;
-  }
-
-  for (i = 0 ; i < NoHandles ; ++i)
-  {
-    Print(L"Playing with driver instance %d...\n", i);
-    Status = PlayWithGnuEfiAppsDrv0Protocol(Handles[i]);
-    if (EFI_ERROR(Status))
-      Print(L"Error playing with instance %d, skipping\n", i);
-  }
-
-  if (Handles)
-    FreePool(Handles);
-
-  return EFI_SUCCESS;
-}

apps/exit.c

@@ -1,12 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	InitializeLib(image_handle, systab);
-
-	Exit(EFI_SUCCESS, 0, NULL);
-
-	return EFI_UNSUPPORTED;
-}

apps/lfbgrid.c

@@ -1,171 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-extern EFI_GUID GraphicsOutputProtocol;
-
-#define be32_to_cpu(x) __builtin_bswap32(x)
-
-static void
-fill_boxes(UINT32 *PixelBuffer, UINT32 Width, UINT32 Height, UINT32 Pitch,
-	   EFI_GRAPHICS_PIXEL_FORMAT Format, EFI_PIXEL_BITMASK Info )
-{
-	UINT32 Red, Green;
-	UINT32 y, x, color;
-
-	switch(Format) {
-	case PixelRedGreenBlueReserved8BitPerColor:
-		Red = be32_to_cpu(0xff000000);
-		Green = be32_to_cpu(0x00ff0000);
-		break;
-	case PixelBlueGreenRedReserved8BitPerColor:
-		Red = be32_to_cpu(0x0000ff00);
-		Green = be32_to_cpu(0x00ff0000);
-		break;
-	case PixelBitMask:
-		Red = Info.RedMask;
-		Green = Info.GreenMask;
-		break;
-	case PixelBltOnly:
-		return;
-	default:
-		Print(L"Invalid pixel format\n");
-		return;
-	}
-
-	for (y = 0; y < Height; y++) {
-		color = ((y / 32) % 2 == 0) ? Red : Green;
-		for (x = 0; x < Width; x++) {
-			if (x % 32 == 0 && x != 0)
-				color = (color == Red) ? Green : Red;
-			PixelBuffer[y * Pitch + x] = color;
-		}
-	}
-}
-
-static void
-draw_boxes(EFI_GRAPHICS_OUTPUT_PROTOCOL *gop)
-{
-	int i, imax;
-	EFI_STATUS rc;
-	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
-	UINTN NumPixels;
-	UINT32 *PixelBuffer;
-	UINT32 CopySize, BufferSize;
-#if __SIZEOF_POINTER__ == 8
-	UINT64 FrameBufferAddr;
-#elif __SIZEOF_POINTER__ == 4
-	UINT32 FrameBufferAddr;
-#else
-#error YOUR ARCH HERE
-#endif
-
-	if (gop->Mode) {
-		imax = gop->Mode->MaxMode;
-	} else {
-		Print(L"gop->Mode is NULL\n");
-		return;
-	}
-
-	for (i = 0; i < imax; i++) {
-		UINTN SizeOfInfo;
-		rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i, &SizeOfInfo,
-					&info);
-		if (rc == EFI_NOT_STARTED) {
-			Print(L"gop->QueryMode() returned %r\n", rc);
-			Print(L"Trying to start GOP with SetMode().\n");
-			rc = uefi_call_wrapper(gop->SetMode, 2, gop,
-				gop->Mode ? gop->Mode->Mode : 0);
-			rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i,
-				&SizeOfInfo, &info);
-		}
-
-		if (EFI_ERROR(rc)) {
-			Print(L"%d: Bad response from QueryMode: %r (%d)\n",
-			      i, rc, rc);
-			continue;
-		}
-
-		if (CompareMem(info, gop->Mode->Info, sizeof (*info)))
-			continue;
-
-		NumPixels = (UINTN)info->VerticalResolution
-                            * (UINTN)info->PixelsPerScanLine;
-		BufferSize = NumPixels * sizeof(UINT32);
-		if (BufferSize == gop->Mode->FrameBufferSize) {
-			CopySize = BufferSize;
-		} else {
-			CopySize = BufferSize < gop->Mode->FrameBufferSize ?
-				BufferSize : gop->Mode->FrameBufferSize;
-			Print(L"height * pitch * pixelsize = %lu buf fb size is %lu; using %lu\n",
-			      BufferSize, gop->Mode->FrameBufferSize, CopySize);
-		}
-
-		PixelBuffer = AllocatePool(BufferSize);
-		if (!PixelBuffer) {
-			Print(L"Allocation of 0x%08lx bytes failed.\n",
-			      sizeof(UINT32) * NumPixels);
-			return;
-		}
-
-		fill_boxes(PixelBuffer, info->HorizontalResolution,
-			   info->VerticalResolution, info->PixelsPerScanLine,
-			   info->PixelFormat, info->PixelInformation);
-
-		if (info->PixelFormat == PixelBltOnly) {
-			Print(L"No linear framebuffer on this device.\n");
-			return;
-		}
-#if __SIZEOF_POINTER__ == 8
-		FrameBufferAddr = (UINT64)gop->Mode->FrameBufferBase;
-#elif __SIZEOF_POINTER__ == 4
-		FrameBufferAddr = (UINT32)(UINT64)gop->Mode->FrameBufferBase;
-#else
-#error YOUR ARCH HERE
-#endif
-
-		CopyMem((VOID *)FrameBufferAddr, PixelBuffer, CopySize);
-		return;
-	}
-	Print(L"Never found the active video mode?\n");
-}
-
-static EFI_STATUS
-SetWatchdog(UINTN seconds)
-{
-	EFI_STATUS rc;
-	rc = uefi_call_wrapper(BS->SetWatchdogTimer, 4, seconds, 0x1ffff,
-				0, NULL);
-	if (EFI_ERROR(rc)) {
-		CHAR16 Buffer[64];
-		StatusToString(Buffer, rc);
-		Print(L"Bad response from QueryMode: %s (%d)\n", Buffer, rc);
-	}
-	return rc;
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS rc;
-	EFI_GRAPHICS_OUTPUT_PROTOCOL *gop;
-
-	InitializeLib(image_handle, systab);
-
-	SetWatchdog(10);
-
-	rc = LibLocateProtocol(&GraphicsOutputProtocol, (void **)&gop);
-	if (EFI_ERROR(rc)) {
-		Print(L"Could not locate GOP: %r\n", rc);
-		return rc;
-	}
-
-	if (!gop) {
-		Print(L"LocateProtocol(GOP, &gop) returned %r but GOP is NULL\n", rc);
-		return EFI_UNSUPPORTED;
-	}
-
-	draw_boxes(gop);
-
-	SetWatchdog(0);
-	return EFI_SUCCESS;
-}

apps/modelist.c

@@ -1,108 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-extern EFI_GUID GraphicsOutputProtocol;
-
-static void
-print_modes(EFI_GRAPHICS_OUTPUT_PROTOCOL *gop)
-{
-	int i, imax;
-	EFI_STATUS rc;
-
-	if (gop->Mode) {
-		imax = gop->Mode->MaxMode;
-		Print(L"GOP reports MaxMode %d\n", imax);
-	} else {
-		Print(L"gop->Mode is NULL\n");
-		imax = 1;
-	}
-
-	for (i = 0; i < imax; i++) {
-		EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
-		UINTN SizeOfInfo;
-		rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i, &SizeOfInfo,
-					&info);
-		if (rc == EFI_NOT_STARTED) {
-			Print(L"gop->QueryMode() returned %r\n", rc);
-			Print(L"Trying to start GOP with SetMode().\n");
-			rc = uefi_call_wrapper(gop->SetMode, 2, gop,
-				gop->Mode ? gop->Mode->Mode : 0);
-			rc = uefi_call_wrapper(gop->QueryMode, 4, gop, i,
-				&SizeOfInfo, &info);
-		}
-
-		if (EFI_ERROR(rc)) {
-			Print(L"%d: Bad response from QueryMode: %r (%d)\n",
-			      i, rc, rc);
-			continue;
-		}
-		Print(L"%c%d: %dx%d ",
-		      (gop->Mode &&
-		       CompareMem(info,gop->Mode->Info,sizeof(*info)) == 0
-		       ) ? '*' : ' ',
-		      i, info->HorizontalResolution, info->VerticalResolution);
-		switch(info->PixelFormat) {
-			case PixelRedGreenBlueReserved8BitPerColor:
-				Print(L"RGBR");
-				break;
-			case PixelBlueGreenRedReserved8BitPerColor:
-				Print(L"BGRR");
-				break;
-			case PixelBitMask:
-				Print(L"R:%08x G:%08x B:%08x X:%08x",
-					info->PixelInformation.RedMask,
-					info->PixelInformation.GreenMask,
-					info->PixelInformation.BlueMask,
-					info->PixelInformation.ReservedMask);
-				break;
-			case PixelBltOnly:
-				Print(L"(blt only)");
-				break;
-			default:
-				Print(L"(Invalid pixel format)");
-				break;
-		}
-		Print(L" pitch %d\n", info->PixelsPerScanLine);
-	}
-}
-
-static EFI_STATUS
-SetWatchdog(UINTN seconds)
-{
-	EFI_STATUS rc;
-	rc = uefi_call_wrapper(BS->SetWatchdogTimer, 4, seconds, 0x1ffff,
-				0, NULL);
-	if (EFI_ERROR(rc)) {
-		CHAR16 Buffer[64];
-		StatusToString(Buffer, rc);
-		Print(L"Bad response from QueryMode: %s (%d)\n", Buffer, rc);
-	}
-	return rc;
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS rc;
-	EFI_GRAPHICS_OUTPUT_PROTOCOL *gop;
-
-	InitializeLib(image_handle, systab);
-
-	SetWatchdog(10);
-
-	rc = LibLocateProtocol(&GraphicsOutputProtocol, (void **)&gop);
-	if (EFI_ERROR(rc)) {
-		Print(L"Could not locate GOP: %r\n", rc);
-		return rc;
-	}
-
-	if (!gop) {
-		Print(L"LocateProtocol(GOP, &gop) returned %r but GOP is NULL\n", rc);
-		return EFI_UNSUPPORTED;
-	}
-
-	print_modes(gop);
-
-	SetWatchdog(0);
-	return EFI_SUCCESS;
-}

apps/printenv.c

@@ -1,32 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS status;
-	CHAR16 name[256], *val, fmt[20];
-	EFI_GUID vendor;
-	UINTN size;
-
-	InitializeLib(image, systab);
-
-	name[0] = 0;
-	vendor = NullGuid;
-
-	Print(L"GUID                                Variable Name        Value\n");
-	Print(L"=================================== ==================== ========\n");
-
-	StrCpy(fmt, L"%.-35g %.-20s %s\n");
-	while (1) {
-		size = sizeof(name);
-		status = uefi_call_wrapper(RT->GetNextVariableName, 3, &size, name, &vendor);
-		if (status != EFI_SUCCESS)
-			break;
-
-		val = LibGetVariable(name, &vendor);
-		Print(fmt, &vendor, name, val);
-		FreePool(val);
-	}
-	return EFI_SUCCESS;
-}

apps/route80h.c

@@ -1,136 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-/* this example program changes the Reserved Page Route (RPR) bit on ICH10's General
- * Control And Status Register (GCS) from LPC to PCI.  In practical terms, it routes
- * outb to port 80h to the PCI bus. */
-
-#define GCS_OFFSET_ADDR 0x3410
-#define GCS_RPR_SHIFT 2
-#define GCS_RPR_PCI 1
-#define GCS_RPR_LPC 0
-
-#define VENDOR_ID_INTEL 0x8086
-#define DEVICE_ID_LPCIF 0x3a16
-#define DEVICE_ID_COUGARPOINT_LPCIF 0x1c56
-
-static EFI_HANDLE ImageHandle;
-
-typedef struct {
-	uint16_t vendor_id;	/* 00-01 */
-	uint16_t device_id;	/* 02-03 */
-	char pad[0xEB];		/* 04-EF */
-	uint32_t rcba;		/* F0-F3 */
-	uint32_t reserved[3];	/* F4-FF */
-} lpcif_t;
-
-static inline void set_bit(volatile uint32_t *flag, int bit, int value)
-{
-	uint32_t val = *flag;
-	Print(L"current value is 0x%2x\n", val);
-
-	if (value) {
-		val |= (1 << bit);
-	} else {
-		val &= ~(1 << bit);
-	}
-	Print(L"setting value to 0x%2x\n", val);
-	*flag = val;
-	val = *flag;
-	Print(L"new value is 0x%2x\n", val);
-}
-
-static int is_device(EFI_PCI_IO *pciio, uint16_t vendor_id, uint16_t device_id)
-{
-	lpcif_t lpcif;
-	EFI_STATUS rc;
-
-	rc = uefi_call_wrapper(pciio->Pci.Read, 5, pciio, EfiPciIoWidthUint16, 0, 2, &lpcif);
-	if (EFI_ERROR(rc))
-		return 0;
-
-	if (vendor_id == lpcif.vendor_id && device_id == lpcif.device_id)
-		return 1;
-	return 0;
-}
-
-static EFI_STATUS find_pci_device(uint16_t vendor_id, uint16_t device_id,
-				EFI_PCI_IO **pciio)
-{
-	EFI_STATUS rc;
-	EFI_HANDLE *Handles;
-	UINTN NoHandles, i;
-
-	if (!pciio)
-		return EFI_INVALID_PARAMETER;
-
-	rc = LibLocateHandle(ByProtocol, &PciIoProtocol, NULL, &NoHandles,
-			     &Handles);
-	if (EFI_ERROR(rc))
-		return rc;
-
-	for (i = 0; i < NoHandles; i++) {
-		void *pciio_tmp = NULL;
-		rc = uefi_call_wrapper(BS->OpenProtocol, 6, Handles[i],
-				    &PciIoProtocol, &pciio_tmp, ImageHandle,
-				    NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
-		if (EFI_ERROR(rc))
-			continue;
-		*pciio = pciio_tmp;
-		if (!is_device(*pciio, vendor_id, device_id)) {
-			*pciio = NULL;
-			continue;
-		}
-
-		return EFI_SUCCESS;
-	}
-	return EFI_NOT_FOUND;
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	InitializeLib(image_handle, systab);
-	EFI_PCI_IO *pciio = NULL;
-	lpcif_t lpcif;
-	EFI_STATUS rc = EFI_SUCCESS;
-	struct {
-		uint16_t vendor;
-		uint16_t device;
-	} devices[] = {
-		{ VENDOR_ID_INTEL, DEVICE_ID_LPCIF },
-		{ VENDOR_ID_INTEL, DEVICE_ID_COUGARPOINT_LPCIF },
-		{ 0, 0 }
-	};
-	int i;
-
-	ImageHandle = image_handle;
-	for (i = 0; devices[i].vendor != 0; i++) {
-		rc = find_pci_device(devices[i].vendor, devices[i].device, &pciio);
-		if (EFI_ERROR(rc))
-			continue;
-	}
-
-	if (rc == EFI_NOT_FOUND) {
-		Print(L"Device not found.\n");
-		return rc;
-	} else if (EFI_ERROR(rc)) {
-		return rc;
-	}
-
-	rc = uefi_call_wrapper(pciio->Pci.Read, 5, pciio, EfiPciIoWidthUint32,
-		EFI_FIELD_OFFSET(lpcif_t, rcba), 1, &lpcif.rcba);
-	if (EFI_ERROR(rc))
-		return rc;
-	if (!(lpcif.rcba & 1)) {
-		Print(L"rcrb is not mapped, cannot route port 80h\n");
-		return EFI_UNSUPPORTED;
-	}
-	lpcif.rcba &= ~1UL;
-
-	Print(L"rcba: 0x%8x\n", lpcif.rcba, lpcif.rcba);
-	set_bit((uint32_t *)(intptr_t)(lpcif.rcba + GCS_OFFSET_ADDR),
-		     GCS_RPR_SHIFT, GCS_RPR_PCI);
-
-	return EFI_SUCCESS;
-}

apps/setdbg.c

@@ -1,37 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_GUID GRUB_EFI_GRUB_VARIABLE_GUID = {0x91376aff,0xcba6,0x42be,{0x94,0x9d,0x06,0xfd,0xe8,0x11,0x28,0xe8}};
-EFI_GUID SHIM_GUID = {0x605dab50,0xe046,0x4300,{0xab,0xb6,0x3d,0xd8,0x10,0xdd,0x8b,0x23}};
-
-char grubenv[] = "# GRUB Environment Block\n\
-debug=tcp,http,net\n\
-####################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################";
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS status;
-	InitializeLib(image, systab);
-#if 0
-	UINT8 data = 1;
-
-	status = RT->SetVariable(L"SHIM_DEBUG", &SHIM_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS |
-				 EFI_VARIABLE_RUNTIME_ACCESS,
-				 sizeof(data), &data);
-	if (EFI_ERROR(status))
-		Print(L"SetVariable failed: %r\n", status);
-#endif
-
-	status = RT->SetVariable(L"GRUB_ENV", &SHIM_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS |
-				 EFI_VARIABLE_RUNTIME_ACCESS,
-				 sizeof(grubenv)-1, grubenv);
-	if (EFI_ERROR(status))
-		Print(L"SetVariable(GRUB_ENV) failed: %r\n", status);
-
-	return EFI_SUCCESS;
-}

apps/setjmp.c

@@ -1,32 +0,0 @@
-
-#include <efi.h>
-#include <efilib.h>
-#include <efisetjmp.h>
-
-EFI_STATUS
-efi_main(
-	EFI_HANDLE image_handle,
-	EFI_SYSTEM_TABLE *systab
-)
-{
-	jmp_buf env;
-	int rc;
-
-	InitializeLib(image_handle, systab);
-	rc = setjmp(env);
-	Print(L"setjmp() = %d\n", rc);
-
-	if (rc == 3) {
-		Print(L"3 worked\n");
-		longjmp(env, 0);
-		return 0;
-	}
-
-	if (rc == 1) {
-		Print(L"0 got to be one yay\n");
-		return 0;
-	}
-
-	longjmp(env, 3);
-	return 0;
-}

apps/t.c

@@ -1,27 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-static CHAR16 *
-a2u (char *str)
-{
-	static CHAR16 mem[2048];
-	int i;
-
-	for (i = 0; str[i]; ++i)
-		mem[i] = (CHAR16) str[i];
-	mem[i] = 0;
-	return mem;
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
-{
-	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
-
-	InitializeLib(image_handle, systab);
-	conout = systab->ConOut;
-	uefi_call_wrapper(conout->OutputString, 2, conout, (CHAR16 *)L"Hello World!\n\r");
-	uefi_call_wrapper(conout->OutputString, 2, conout, a2u("Hello World!\n\r"));
-
-	return EFI_SUCCESS;
-}

apps/t2.c

@@ -1,14 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
-
-        InitializeLib(image, systab);
-	conout = systab->ConOut;
-	uefi_call_wrapper(conout->OutputString, 2, conout, L"Hello World!\n\r");
-
-	return EFI_SUCCESS;
-}

apps/t3.c

@@ -1,95 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main(
-	EFI_HANDLE image_handle,
-	EFI_SYSTEM_TABLE *systab
-)
-{
-	EFI_GUID loaded_image_protocol = LOADED_IMAGE_PROTOCOL;
-	EFI_STATUS efi_status;
-	EFI_LOADED_IMAGE *li;
-	UINTN pat = PoolAllocationType;
-	VOID *void_li_p;
-
-	InitializeLib(image_handle, systab);
-	PoolAllocationType = 2; /* klooj */
-
-	Print(L"Hello World! (0xd=0x%x, 13=%d)\n", 13, 13);
-
-	Print(L"before InitializeLib(): PoolAllocationType=%d\n",
-		pat);
-
-	Print(L" after InitializeLib(): PoolAllocationType=%d\n",
-		PoolAllocationType);
-
-	/*
-	 * Locate loaded_image_handle instance.
-	 */
-
-	Print(L"BS->HandleProtocol()  ");
-
-	efi_status = uefi_call_wrapper(
-		BS->HandleProtocol,
-		3,
-		image_handle,
-		&loaded_image_protocol,
-		&void_li_p);
-	li = void_li_p;
-
-	Print(L"%xh (%r)\n", efi_status, efi_status);
-
-	if (efi_status != EFI_SUCCESS) {
-		return efi_status;
-	}
-
-	Print(L"  li: %xh\n", li);
-
-	if (!li) {
-		return EFI_UNSUPPORTED;
-	}
-
-	Print(L"  li->Revision:        %xh\n", li->Revision);
-	Print(L"  li->ParentHandle:    %xh\n", li->ParentHandle);
-	Print(L"  li->SystemTable:     %xh\n", li->SystemTable);
-	Print(L"  li->DeviceHandle:    %xh\n", li->DeviceHandle);
-	Print(L"  li->FilePath:        %xh\n", li->FilePath);
-	Print(L"  li->Reserved:        %xh\n", li->Reserved);
-	Print(L"  li->LoadOptionsSize: %xh\n", li->LoadOptionsSize);
-	Print(L"  li->LoadOptions:     %xh\n", li->LoadOptions);
-	Print(L"  li->ImageBase:       %xh\n", li->ImageBase);
-	Print(L"  li->ImageSize:       %xh\n", li->ImageSize);
-	Print(L"  li->ImageCodeType:   %xh\n", li->ImageCodeType);
-	Print(L"  li->ImageDataType:   %xh\n", li->ImageDataType);
-	Print(L"  li->Unload:          %xh\n", li->Unload);
-
-#if 0
-typedef struct {
-    UINT32                          Revision;
-    EFI_HANDLE                      ParentHandle;
-    struct _EFI_SYSTEM_TABLE        *SystemTable;
-
-    // Source location of image
-    EFI_HANDLE                      DeviceHandle;
-    EFI_DEVICE_PATH                 *FilePath;
-    VOID                            *Reserved;
-
-    // Images load options
-    UINT32                          LoadOptionsSize;
-    VOID                            *LoadOptions;
-
-    // Location of where image was loaded
-    VOID                            *ImageBase;
-    UINT64                          ImageSize;
-    EFI_MEMORY_TYPE                 ImageCodeType;
-    EFI_MEMORY_TYPE                 ImageDataType;
-
-    // If the driver image supports a dynamic unload request
-    EFI_IMAGE_UNLOAD                Unload;
-
-} EFI_LOADED_IMAGE;
-#endif
-
-	return EFI_SUCCESS;
-}

apps/t4.c

@@ -1,14 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE *image, EFI_SYSTEM_TABLE *systab)
-{
-	UINTN index;
-
-        InitializeLib(image, systab);
-	uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut, L"Hello application started\r\n");
-	uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut, L"\r\n\r\n\r\nHit any key to exit\r\n");
-	uefi_call_wrapper(systab->BootServices->WaitForEvent, 3, 1, &systab->ConIn->WaitForKey, &index);
-	return EFI_SUCCESS;
-}

apps/t5.c

@@ -1,13 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	InitializeLib(image, systab);
-	Print(L"HelloLib application started\n");
-	Print(L"\n\n\nHit any key to exit this image\n");
-	WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
-	uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"\n\n");
-	return EFI_SUCCESS;
-}

apps/t6.c

@@ -1,43 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-typedef EFI_STATUS (*foo_t)(EFI_HANDLE, EFI_GUID *, VOID **);
-typedef struct {
-	unsigned long addr;
-	unsigned long gp;
-} fdesc_t;
-
-EFI_LOADED_IMAGE my_loaded;
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_LOADED_IMAGE *loaded_image = NULL;
-#if 0
-	EFI_DEVICE_PATH *dev_path;
-#endif
-	EFI_STATUS status;
-
-	InitializeLib(image, systab);
-	status = uefi_call_wrapper(systab->BootServices->HandleProtocol,
-				3,
-				image, 
-				&LoadedImageProtocol, 
-				(void **) &loaded_image);
-	if (EFI_ERROR(status)) {
-		Print(L"handleprotocol: %r\n", status);
-	}
-
-#if 0
-	BS->HandleProtocol(loaded_image->DeviceHandle, &DevicePathProtocol, (void **) &dev_path);
-
-	Print(L"Image device      : %s\n", DevicePathToStr(dev_path));
-	Print(L"Image file        : %s\n", DevicePathToStr(loaded_image->FilePath));
-#endif
-	Print(L"Image base        : %lx\n", loaded_image->ImageBase);
-	Print(L"Image size        : %lx\n", loaded_image->ImageSize);
-	Print(L"Load options size : %lx\n", loaded_image->LoadOptionsSize);
-	Print(L"Load options      : %s\n", loaded_image->LoadOptions);
-
-	return EFI_SUCCESS;
-}

apps/t7.c

@@ -1,25 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_INPUT_KEY efi_input_key;
-	EFI_STATUS efi_status;
-
-	InitializeLib(image, systab);
-
-	Print(L"HelloLib application started\n");
-
-	Print(L"\n\n\nHit any key to exit this image\n");
-	WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
-
-	uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"\n\n");
-
-	efi_status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn, &efi_input_key);
-
-	Print(L"ScanCode: %xh  UnicodeChar: %xh CallRtStatus: %x\n",
-		efi_input_key.ScanCode, efi_input_key.UnicodeChar, efi_status);
-
-	return EFI_SUCCESS;
-}

apps/t8.c

@@ -1,19 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
-{
-  INTN Argc, i;
-  CHAR16 **Argv;
-
-  InitializeLib(ImageHandle, SystemTable);
-  Argc = GetShellArgcArgv(ImageHandle, &Argv);
-
-  Print(L"Hello World, started with Argc=%d\n", Argc);
-  for (i = 0 ; i < Argc ; ++i)
-    Print(L"  Argv[%d] = '%s'\n", i, Argv[i]);
-
-  Print(L"Bye.\n");
-  return EFI_SUCCESS;
-}

apps/tcc.c

@@ -1,431 +0,0 @@
-/*
- * Test if our calling convention gymnastics actually work
- */
-
-#include <efi.h>
-#include <efilib.h>
-
-#if 0
-extern void dump_stack(void);
-asm(	".globl	dump_stack\n"
-	"dump_stack:\n"
-	"	movq %rsp, %rdi\n"
-	"	jmp *dump_stack_helper@GOTPCREL(%rip)\n"
-	".size	dump_stack, .-dump_stack");
-
-void dump_stack_helper(uint64_t rsp_val)
-{
-	uint64_t *rsp = (uint64_t *)rsp_val;
-	int x;
-
-	Print(L"%%rsp: 0x%08x%08x stack:\r\n",
-					(rsp_val & 0xffffffff00000000) >>32,
-					 rsp_val & 0xffffffff);
-	for (x = 0; x < 8; x++) {
-		Print(L"%08x: ", ((uint64_t)rsp) & 0xffffffff);
-		Print(L"%016x ", *rsp++);
-		Print(L"%016x ", *rsp++);
-		Print(L"%016x ", *rsp++);
-		Print(L"%016x\r\n", *rsp++);
-	}
-}
-#endif
-
-EFI_STATUS EFI_FUNCTION test_failure_callback(void)
-{
-	return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS test_failure(void)
-{
-	return uefi_call_wrapper(test_failure_callback, 0);
-}
-
-EFI_STATUS EFI_FUNCTION test_call0_callback(void)
-{
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call0(void)
-{
-	return uefi_call_wrapper(test_call0_callback, 0);
-}
-
-EFI_STATUS EFI_FUNCTION test_call1_callback(UINT32 a)
-{
-	if (a != 0x12345678) {
-		return EFI_LOAD_ERROR;
-	}
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call1(void)
-{
-	return uefi_call_wrapper(test_call1_callback, 1,0x12345678);
-}
-
-EFI_STATUS EFI_FUNCTION test_call2_callback(UINT32 a, UINT32 b)
-{
-	if (a != 0x12345678) {
-		return EFI_LOAD_ERROR;
-	}
-	if (b != 0x23456789) {
-		return EFI_INVALID_PARAMETER;
-	}
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call2(void)
-{
-	return uefi_call_wrapper(test_call2_callback, 2,
-		0x12345678, 0x23456789);
-}
-
-EFI_STATUS EFI_FUNCTION test_call3_callback(UINT32 a, UINT32 b,
-	UINT32 c)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call3(void)
-{
-	return uefi_call_wrapper(test_call3_callback, 3,
-		0x12345678, 0x23456789, 0x3456789a);
-}
-
-EFI_STATUS EFI_FUNCTION test_call4_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call4(void)
-{
-	return uefi_call_wrapper(test_call4_callback, 4,
-		0x12345678, 0x23456789, 0x3456789a, 0x456789ab);
-}
-
-EFI_STATUS EFI_FUNCTION test_call5_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call5(void)
-{
-	return uefi_call_wrapper(test_call5_callback, 5,
-		0x12345678, 0x23456789, 0x3456789a, 0x456789ab, 0x56789abc);
-}
-
-EFI_STATUS EFI_FUNCTION test_call6_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e, UINT32 f)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-	if (f != 0x6789abcd)
-		return EFI_NOT_READY;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call6(void)
-{
-	return uefi_call_wrapper(test_call6_callback, 6,
-		0x12345678, 0x23456789, 0x3456789a, 0x456789ab, 0x56789abc,
-		0x6789abcd);
-}
-
-EFI_STATUS EFI_FUNCTION test_call7_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e, UINT32 f, UINT32 g)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-	if (f != 0x6789abcd)
-		return EFI_NOT_READY;
-	if (g != 0x789abcde)
-		return EFI_DEVICE_ERROR;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call7(void)
-{
-	return uefi_call_wrapper(test_call7_callback, 7,
-		0x12345678, 0x23456789, 0x3456789a, 0x456789ab,
-		0x56789abc, 0x6789abcd, 0x789abcde);
-}
-
-EFI_STATUS EFI_FUNCTION test_call8_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e, UINT32 f, UINT32 g, UINT32 h)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-	if (f != 0x6789abcd)
-		return EFI_NOT_READY;
-	if (g != 0x789abcde)
-		return EFI_DEVICE_ERROR;
-	if (h != 0x89abcdef)
-		return EFI_WRITE_PROTECTED;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call8(void)
-{
-	return uefi_call_wrapper(test_call8_callback, 8,
-		0x12345678,
-		0x23456789,
-		0x3456789a,
-		0x456789ab,
-		0x56789abc,
-		0x6789abcd,
-		0x789abcde,
-		0x89abcdef);
-}
-
-EFI_STATUS EFI_FUNCTION test_call9_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e, UINT32 f, UINT32 g, UINT32 h, UINT32 i)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-	if (f != 0x6789abcd)
-		return EFI_NOT_READY;
-	if (g != 0x789abcde)
-		return EFI_DEVICE_ERROR;
-	if (h != 0x89abcdef)
-		return EFI_WRITE_PROTECTED;
-	if (i != 0x9abcdef0)
-		return EFI_OUT_OF_RESOURCES;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call9(void)
-{
-	return uefi_call_wrapper(test_call9_callback, 9,
-		0x12345678,
-		0x23456789,
-		0x3456789a,
-		0x456789ab,
-		0x56789abc,
-		0x6789abcd,
-		0x789abcde,
-		0x89abcdef,
-		0x9abcdef0);
-}
-
-extern EFI_STATUS test_call10(void);
-EFI_STATUS EFI_FUNCTION test_call10_callback(UINT32 a, UINT32 b,
-	UINT32 c, UINT32 d, UINT32 e, UINT32 f, UINT32 g, UINT32 h, UINT32 i,
-	UINT32 j)
-{
-	if (a != 0x12345678)
-		return EFI_LOAD_ERROR;
-	if (b != 0x23456789)
-		return EFI_INVALID_PARAMETER;
-	if (c != 0x3456789a)
-		return EFI_UNSUPPORTED;
-	if (d != 0x456789ab)
-		return EFI_BAD_BUFFER_SIZE;
-	if (e != 0x56789abc)
-		return EFI_BUFFER_TOO_SMALL;
-	if (f != 0x6789abcd)
-		return EFI_NOT_READY;
-	if (g != 0x789abcde)
-		return EFI_DEVICE_ERROR;
-	if (h != 0x89abcdef)
-		return EFI_WRITE_PROTECTED;
-	if (i != 0x9abcdef0)
-		return EFI_OUT_OF_RESOURCES;
-	if (j != 0xabcdef01)
-		return EFI_VOLUME_CORRUPTED;
-
-	return EFI_SUCCESS;
-}
-
-EFI_STATUS test_call10(void)
-{
-	return uefi_call_wrapper(test_call10_callback, 10,
-		0x12345678,
-		0x23456789,
-		0x3456789a,
-		0x456789ab,
-		0x56789abc,
-		0x6789abcd,
-		0x789abcde,
-		0x89abcdef,
-		0x9abcdef0,
-		0xabcdef01);
-}
-
-EFI_STATUS
-efi_main (EFI_HANDLE *image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS rc = EFI_SUCCESS;
-
-	InitializeLib(image, systab);
-	PoolAllocationType = 2; /* klooj */
-
-#ifdef __x86_64__
-	__asm__ volatile("out %0,%1" : : "a" ((uint8_t)0x14), "dN" (0x80));
-#endif
-
-	Print(L"Hello\r\n");
-	rc = test_failure();
-	if (EFI_ERROR(rc)) {
-		Print(L"Returning Failure works\n");
-	} else {
-		Print(L"Returning failure doesn't work.\r\n");
-		Print(L"%%rax was 0x%016x, should have been 0x%016x\n",
-			rc, EFI_UNSUPPORTED);
-		return EFI_INVALID_PARAMETER;
-	}
-
-	rc = test_call0();
-	if (!EFI_ERROR(rc)) {
-		Print(L"0 args works just fine here.\r\n");
-	} else {
-		Print(L"0 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call1();
-	if (!EFI_ERROR(rc)) {
-		Print(L"1 arg works just fine here.\r\n");
-	} else {
-		Print(L"1 arg failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call2();
-	if (!EFI_ERROR(rc)) {
-		Print(L"2 args works just fine here.\r\n");
-	} else {
-		Print(L"2 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call3();
-	if (!EFI_ERROR(rc)) {
-		Print(L"3 args works just fine here.\r\n");
-	} else {
-		Print(L"3 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call4();
-	if (!EFI_ERROR(rc)) {
-		Print(L"4 args works just fine here.\r\n");
-	} else {
-		Print(L"4 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call5();
-	if (!EFI_ERROR(rc)) {
-		Print(L"5 args works just fine here.\r\n");
-	} else {
-		Print(L"5 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call6();
-	if (!EFI_ERROR(rc)) {
-		Print(L"6 args works just fine here.\r\n");
-	} else {
-		Print(L"6 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call7();
-	if (!EFI_ERROR(rc)) {
-		Print(L"7 args works just fine here.\r\n");
-	} else {
-		Print(L"7 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call8();
-	if (!EFI_ERROR(rc)) {
-		Print(L"8 args works just fine here.\r\n");
-	} else {
-		Print(L"8 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call9();
-	if (!EFI_ERROR(rc)) {
-		Print(L"9 args works just fine here.\r\n");
-	} else {
-		Print(L"9 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	rc = test_call10();
-	if (!EFI_ERROR(rc)) {
-		Print(L"10 args works just fine here.\r\n");
-	} else {
-		Print(L"10 args failed: 0x%016x\n", rc);
-		return rc;
-	}
-
-	return rc;
-}

apps/tpause.c

@@ -1,9 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	Print(L"Press `q' to quit, any other key to continue:\n");
-	
-}

apps/trivial.S

@@ -1,47 +0,0 @@
-	.text
-	.align 4
-
-	.globl _start
-_start:
-#if 0
-        pushl %ebp
-        movl %esp,%ebp
-        pushl %ebx		# save ebx
-        movl 12(%ebp),%eax	# eax <- systab
-	movl 24(%eax),%ebx	# ebx <- systab->FirmwareVendor
-	pushl %ebx
-        movl 44(%eax),%ebx	# ebx <- systab->ConOut
-        pushl %ebx
-        movl 4(%ebx),%eax	# eax <- conout->OutputString
-        call *%eax
-        movl -4(%ebp),%ebx	# restore ebx
-        leave
-        ret
-
-#else
-
-        pushl %ebp
-        movl %esp,%ebp
-        pushl %ebx
-	call 0f
-0:	popl %eax
-	addl $hello-0b,%eax
-	pushl %eax
-        movl 12(%ebp),%eax	# eax <- systab
-        movl 44(%eax),%ebx	# ebx <- systab->ConOut
-        pushl %ebx
-        movl 4(%ebx),%eax	# eax <- conout->OutputString
-        call *%eax
-        movl -4(%ebp),%ebx
-        leave
-        ret
-
-	.section .rodata
-	.align 2
-hello:	.byte 'h',0,'e',0,'l',0,'l',0,'o',0,'\n',0,'\r',0,0,0
-
-#endif
-
-#if defined(__ELF__) && defined(__linux__)
-	.section .note.GNU-stack,"",%progbits
-#endif

apps/unsetdbg.c

@@ -1,37 +0,0 @@
-#include <efi.h>
-#include <efilib.h>
-
-EFI_GUID GRUB_EFI_GRUB_VARIABLE_GUID = {0x91376aff,0xcba6,0x42be,{0x94,0x9d,0x06,0xfd,0xe8,0x11,0x28,0xe8}};
-EFI_GUID SHIM_GUID = {0x605dab50,0xe046,0x4300,{0xab,0xb6,0x3d,0xd8,0x10,0xdd,0x8b,0x23}};
-
-char grubenv[] = "# GRUB Environment Block\n\
-debug=all\n\
-#############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################";
-
-EFI_STATUS
-efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
-{
-	EFI_STATUS status;
-	UINT8 data = 1;
-	InitializeLib(image, systab);
-
-	status = RT->SetVariable(L"SHIM_DEBUG", &SHIM_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS |
-				 EFI_VARIABLE_RUNTIME_ACCESS,
-				 0, &data);
-	if (EFI_ERROR(status))
-		Print(L"SetVariable failed: %r\n", status);
-
-#if 0
-	status = RT->SetVariable(L"GRUB_ENV", &SHIM_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS |
-				 EFI_VARIABLE_RUNTIME_ACCESS,
-				 sizeof(grubenv)-1, grubenv);
-	if (EFI_ERROR(status))
-		Print(L"SetVariable(GRUB_ENV) failed: %r\n", status);
-#endif
-
-	return EFI_SUCCESS;
-}