/*+++ | |
Copyright (c) 2006, Intel Corporation | |
All rights reserved. This program and the accompanying materials | |
are licensed and made available under the terms and conditions of the BSD License | |
which accompanies this distribution. The full text of the license may be found at | |
http://opensource.org/licenses/bsd-license.php | |
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
Module Name: | |
UnixBusDriver.c | |
Abstract: | |
This following section documents the envirnoment variables for the Win UNIX | |
build. These variables are used to define the (virtual) hardware | |
configuration of the UNIX environment | |
A ! can be used to seperate multiple instances in a variable. Each | |
instance represents a seperate hardware device. | |
EFI_UNIX_PHYSICAL_DISKS - maps to drives on your system | |
EFI_UNIX_VIRTUAL_DISKS - maps to a device emulated by a file | |
EFI_UNIX_FILE_SYSTEM - mouts a directory as a file system | |
EFI_UNIX_CONSOLE - make a logical comand line window (only one!) | |
EFI_UNIX_UGA - Builds UGA Windows of Width and Height | |
<F>ixed - Fixed disk like a hard drive. | |
<R>emovable - Removable media like a floppy or CD-ROM. | |
Read <O>nly - Write protected device. | |
Read <W>rite - Read write device. | |
<block count> - Decimal number of blocks a device supports. | |
<block size> - Decimal number of bytes per block. | |
UNIX envirnonment variable contents. '<' and '>' are not part of the variable, | |
they are just used to make this help more readable. There should be no | |
spaces between the ';'. Extra spaces will break the variable. A '!' is | |
used to seperate multiple devices in a variable. | |
EFI_UNIX_VIRTUAL_DISKS = | |
<F | R><O | W>;<block count>;<block size>[!...] | |
EFI_UNIX_PHYSICAL_DISKS = | |
<drive letter>:<F | R><O | W>;<block count>;<block size>[!...] | |
Virtual Disks: These devices use a file to emulate a hard disk or removable | |
media device. | |
Thus a 20 MB emulated hard drive would look like: | |
EFI_UNIX_VIRTUAL_DISKS=FW;40960;512 | |
A 1.44MB emulated floppy with a block size of 1024 would look like: | |
EFI_UNIX_VIRTUAL_DISKS=RW;1440;1024 | |
Physical Disks: These devices use UNIX to open a real device in your system | |
Thus a 120 MB floppy would look like: | |
EFI_UNIX_PHYSICAL_DISKS=B:RW;245760;512 | |
Thus a standard CD-ROM floppy would look like: | |
EFI_UNIX_PHYSICAL_DISKS=Z:RO;307200;2048 | |
EFI_UNIX_FILE_SYSTEM = | |
<directory path>[!...] | |
Mounting the two directories C:\FOO and C:\BAR would look like: | |
EFI_UNIX_FILE_SYSTEM=c:\foo!c:\bar | |
EFI_UNIX_CONSOLE = | |
<window title> | |
Declaring a text console window with the title "My EFI Console" woild look like: | |
EFI_UNIX_CONSOLE=My EFI Console | |
EFI_UNIX_UGA = | |
<width> <height>[!...] | |
Declaring a two UGA windows with resolutions of 800x600 and 1024x768 would look like: | |
Example : EFI_UNIX_UGA=800 600!1024 768 | |
EFI_UNIX_PASS_THROUGH = | |
<BaseAddress>;<Bus#>;<Device#>;<Function#> | |
Declaring a base address of 0xE0000000 (used for PCI Express devices) | |
and having NT32 talk to a device located at bus 0, device 1, function 0: | |
Example : EFI_UNIX_PASS_THROUGH=E000000;0;1;0 | |
---*/ | |
#include "UnixBusDriver.h" | |
// | |
// Define GUID for the Unix Bus Driver | |
// | |
EFI_GUID gUnixBusDriverGuid = { | |
0x419f582, 0x625, 0x4531, {0x8a, 0x33, 0x85, 0xa9, 0x96, 0x5c, 0x95, 0xbc} | |
}; | |
// | |
// DriverBinding protocol global | |
// | |
EFI_DRIVER_BINDING_PROTOCOL gUnixBusDriverBinding = { | |
UnixBusDriverBindingSupported, | |
UnixBusDriverBindingStart, | |
UnixBusDriverBindingStop, | |
0xa, | |
NULL, | |
NULL | |
}; | |
#define UNIX_PCD_ARRAY_SIZE (sizeof(mPcdEnvironment)/sizeof(UNIX_PCD_ENTRY)) | |
// | |
// Table to map UNIX Environment variable to the GUID that should be in | |
// device path. | |
// | |
UNIX_PCD_ENTRY mPcdEnvironment[] = { | |
{PcdToken(PcdUnixConsole), &gEfiUnixConsoleGuid}, | |
{PcdToken(PcdUnixUga), &gEfiUnixUgaGuid}, | |
{PcdToken(PcdUnixFileSystem), &gEfiUnixFileSystemGuid}, | |
{PcdToken(PcdUnixSerialPort), &gEfiUnixSerialPortGuid}, | |
{PcdToken(PcdUnixVirtualDisk), &gEfiUnixVirtualDisksGuid}, | |
{PcdToken(PcdUnixPhysicalDisk), &gEfiUnixPhysicalDisksGuid}, | |
{PcdToken(PcdUnixCpuModel), &gEfiUnixCPUModelGuid}, | |
{PcdToken(PcdUnixCpuSpeed), &gEfiUnixCPUSpeedGuid}, | |
{PcdToken(PcdUnixMemorySize), &gEfiUnixMemoryGuid} | |
}; | |
VOID * | |
AllocateMemory ( | |
IN UINTN Size | |
) | |
{ | |
EFI_STATUS Status; | |
VOID *Buffer; | |
Status = gBS->AllocatePool ( | |
EfiBootServicesData, | |
Size, | |
(VOID *)&Buffer | |
); | |
if (EFI_ERROR (Status)) { | |
ASSERT (FALSE); | |
return NULL; | |
} | |
return Buffer; | |
} | |
EFI_STATUS | |
EFIAPI | |
UnixBusDriverBindingSupported ( | |
IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
IN EFI_HANDLE ControllerHandle, | |
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
) | |
/*++ | |
Routine Description: | |
Arguments: | |
Returns: | |
None | |
--*/ | |
// TODO: This - add argument and description to function comment | |
// TODO: ControllerHandle - add argument and description to function comment | |
// TODO: RemainingDevicePath - add argument and description to function comment | |
// TODO: EFI_UNSUPPORTED - add return value to function comment | |
// TODO: EFI_UNSUPPORTED - add return value to function comment | |
// TODO: EFI_SUCCESS - add return value to function comment | |
// TODO: EFI_SUCCESS - add return value to function comment | |
{ | |
EFI_STATUS Status; | |
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; | |
EFI_UNIX_THUNK_PROTOCOL *UnixThunk; | |
UINTN Index; | |
// | |
// Check the contents of the first Device Path Node of RemainingDevicePath to make sure | |
// it is a legal Device Path Node for this bus driver's children. | |
// | |
if (RemainingDevicePath != NULL) { | |
if (RemainingDevicePath->Type != HARDWARE_DEVICE_PATH || | |
RemainingDevicePath->SubType != HW_VENDOR_DP || | |
DevicePathNodeLength(RemainingDevicePath) != sizeof(UNIX_VENDOR_DEVICE_PATH_NODE)) { | |
return EFI_UNSUPPORTED; | |
} | |
for (Index = 0; Index < UNIX_PCD_ARRAY_SIZE; Index++) { | |
if (CompareGuid (&((VENDOR_DEVICE_PATH *) RemainingDevicePath)->Guid, mPcdEnvironment[Index].DevicePathGuid)) { | |
break; | |
} | |
} | |
if (Index >= UNIX_PCD_ARRAY_SIZE) { | |
return EFI_UNSUPPORTED; | |
} | |
} | |
// | |
// Open the IO Abstraction(s) needed to perform the supported test | |
// | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiDevicePathProtocolGuid, | |
(VOID **)&ParentDevicePath, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_BY_DRIVER | |
); | |
if (Status == EFI_ALREADY_STARTED) { | |
return EFI_SUCCESS; | |
} | |
if (EFI_ERROR (Status)) { | |
return Status; | |
} | |
gBS->CloseProtocol ( | |
ControllerHandle, | |
&gEfiDevicePathProtocolGuid, | |
This->DriverBindingHandle, | |
ControllerHandle | |
); | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
(VOID **)&UnixThunk, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_BY_DRIVER | |
); | |
if (Status == EFI_ALREADY_STARTED) { | |
return EFI_SUCCESS; | |
} | |
if (EFI_ERROR (Status)) { | |
return Status; | |
} | |
// | |
// Since we call through UnixThunk we need to make sure it's valid | |
// | |
Status = EFI_SUCCESS; | |
if (UnixThunk->Signature != EFI_UNIX_THUNK_PROTOCOL_SIGNATURE) { | |
Status = EFI_UNSUPPORTED; | |
} | |
// | |
// Close the I/O Abstraction(s) used to perform the supported test | |
// | |
gBS->CloseProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
This->DriverBindingHandle, | |
ControllerHandle | |
); | |
return Status; | |
} | |
EFI_STATUS | |
EFIAPI | |
UnixBusDriverBindingStart ( | |
IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
IN EFI_HANDLE ControllerHandle, | |
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
) | |
/*++ | |
Routine Description: | |
Arguments: | |
Returns: | |
None | |
--*/ | |
// TODO: This - add argument and description to function comment | |
// TODO: ControllerHandle - add argument and description to function comment | |
// TODO: RemainingDevicePath - add argument and description to function comment | |
// TODO: EFI_OUT_OF_RESOURCES - add return value to function comment | |
// TODO: EFI_OUT_OF_RESOURCES - add return value to function comment | |
// TODO: EFI_SUCCESS - add return value to function comment | |
{ | |
EFI_STATUS Status; | |
EFI_STATUS InstallStatus; | |
EFI_UNIX_THUNK_PROTOCOL *UnixThunk; | |
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; | |
UNIX_BUS_DEVICE *UnixBusDevice; | |
UNIX_IO_DEVICE *UnixDevice; | |
UINTN Index; | |
CHAR16 *StartString; | |
CHAR16 *SubString; | |
UINT16 Count; | |
UINTN StringSize; | |
UINT16 ComponentName[MAX_UNIX_ENVIRNMENT_VARIABLE_LENGTH]; | |
UNIX_VENDOR_DEVICE_PATH_NODE *Node; | |
BOOLEAN CreateDevice; | |
CHAR16 *TempStr; | |
CHAR16 *PcdTempStr; | |
UINTN TempStrSize; | |
Status = EFI_UNSUPPORTED; | |
// | |
// Grab the protocols we need | |
// | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiDevicePathProtocolGuid, | |
(VOID **)&ParentDevicePath, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_BY_DRIVER | |
); | |
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) { | |
return Status; | |
} | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
(VOID **)&UnixThunk, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_BY_DRIVER | |
); | |
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) { | |
return Status; | |
} | |
if (Status != EFI_ALREADY_STARTED) { | |
Status = gBS->AllocatePool ( | |
EfiBootServicesData, | |
sizeof (UNIX_BUS_DEVICE), | |
(VOID *) &UnixBusDevice | |
); | |
if (EFI_ERROR (Status)) { | |
return Status; | |
} | |
UnixBusDevice->Signature = UNIX_BUS_DEVICE_SIGNATURE; | |
UnixBusDevice->ControllerNameTable = NULL; | |
AddUnicodeString ( | |
"eng", | |
gUnixBusDriverComponentName.SupportedLanguages, | |
&UnixBusDevice->ControllerNameTable, | |
L"Unix Bus Controller" | |
); | |
Status = gBS->InstallMultipleProtocolInterfaces ( | |
&ControllerHandle, | |
&gUnixBusDriverGuid, | |
UnixBusDevice, | |
NULL | |
); | |
if (EFI_ERROR (Status)) { | |
FreeUnicodeStringTable (UnixBusDevice->ControllerNameTable); | |
gBS->FreePool (UnixBusDevice); | |
return Status; | |
} | |
} | |
// | |
// Loop on the Variable list. Parse each variable to produce a set of handles that | |
// represent virtual hardware devices. | |
// | |
InstallStatus = EFI_NOT_FOUND; | |
for (Index = 0; Index < UNIX_PCD_ARRAY_SIZE; Index++) { | |
PcdTempStr = (VOID *)LibPcdGetPtr (mPcdEnvironment[Index].Token); | |
ASSERT (PcdTempStr != NULL); | |
TempStrSize = StrLen (PcdTempStr); | |
TempStr = AllocateMemory ((TempStrSize * sizeof (CHAR16)) + 1); | |
StrCpy (TempStr, PcdTempStr); | |
StartString = TempStr; | |
// | |
// Parse the envirnment variable into sub strings using '!' as a delimator. | |
// Each substring needs it's own handle to be added to the system. This code | |
// does not understand the sub string. Thats the device drivers job. | |
// | |
Count = 0; | |
while (*StartString != '\0') { | |
// | |
// Find the end of the sub string | |
// | |
SubString = StartString; | |
while (*SubString != '\0' && *SubString != '!') { | |
SubString++; | |
} | |
if (*SubString == '!') { | |
// | |
// Replace token with '\0' to make sub strings. If this is the end | |
// of the string SubString will already point to NULL. | |
// | |
*SubString = '\0'; | |
SubString++; | |
} | |
CreateDevice = TRUE; | |
if (RemainingDevicePath != NULL) { | |
CreateDevice = FALSE; | |
Node = (UNIX_VENDOR_DEVICE_PATH_NODE *) RemainingDevicePath; | |
if (Node->VendorDevicePath.Header.Type == HARDWARE_DEVICE_PATH && | |
Node->VendorDevicePath.Header.SubType == HW_VENDOR_DP && | |
DevicePathNodeLength (&Node->VendorDevicePath.Header) == sizeof (UNIX_VENDOR_DEVICE_PATH_NODE) | |
) { | |
if (CompareGuid (&Node->VendorDevicePath.Guid, mPcdEnvironment[Index].DevicePathGuid) && | |
Node->Instance == Count | |
) { | |
CreateDevice = TRUE; | |
} | |
} | |
} | |
if (CreateDevice) { | |
// | |
// Allocate instance structure, and fill in parent information. | |
// | |
UnixDevice = AllocateMemory (sizeof (UNIX_IO_DEVICE)); | |
if (UnixDevice == NULL) { | |
return EFI_OUT_OF_RESOURCES; | |
} | |
UnixDevice->Handle = NULL; | |
UnixDevice->ControllerHandle = ControllerHandle; | |
UnixDevice->ParentDevicePath = ParentDevicePath; | |
UnixDevice->UnixIo.UnixThunk = UnixThunk; | |
// | |
// Plus 2 to account for the NULL at the end of the Unicode string | |
// | |
StringSize = (UINTN) ((UINT8 *) SubString - (UINT8 *) StartString) + sizeof (CHAR16); | |
UnixDevice->UnixIo.EnvString = AllocateMemory (StringSize); | |
if (UnixDevice->UnixIo.EnvString != NULL) { | |
CopyMem (UnixDevice->UnixIo.EnvString, StartString, StringSize); | |
} | |
UnixDevice->ControllerNameTable = NULL; | |
// FIXME: check size | |
StrCpy(ComponentName, UnixDevice->UnixIo.EnvString); | |
UnixDevice->DevicePath = UnixBusCreateDevicePath ( | |
ParentDevicePath, | |
mPcdEnvironment[Index].DevicePathGuid, | |
Count | |
); | |
if (UnixDevice->DevicePath == NULL) { | |
gBS->FreePool (UnixDevice); | |
return EFI_OUT_OF_RESOURCES; | |
} | |
AddUnicodeString ( | |
"eng", | |
gUnixBusDriverComponentName.SupportedLanguages, | |
&UnixDevice->ControllerNameTable, | |
ComponentName | |
); | |
UnixDevice->UnixIo.TypeGuid = mPcdEnvironment[Index].DevicePathGuid; | |
UnixDevice->UnixIo.InstanceNumber = Count; | |
UnixDevice->Signature = UNIX_IO_DEVICE_SIGNATURE; | |
Status = gBS->InstallMultipleProtocolInterfaces ( | |
&UnixDevice->Handle, | |
&gEfiDevicePathProtocolGuid, | |
UnixDevice->DevicePath, | |
&gEfiUnixIoProtocolGuid, | |
&UnixDevice->UnixIo, | |
NULL | |
); | |
if (EFI_ERROR (Status)) { | |
FreeUnicodeStringTable (UnixDevice->ControllerNameTable); | |
gBS->FreePool (UnixDevice); | |
} else { | |
// | |
// Open For Child Device | |
// | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
(VOID **)&UnixThunk, | |
This->DriverBindingHandle, | |
UnixDevice->Handle, | |
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER | |
); | |
if (!EFI_ERROR (Status)) { | |
InstallStatus = EFI_SUCCESS; | |
} | |
} | |
} | |
// | |
// Parse Next sub string. This will point to '\0' if we are at the end. | |
// | |
Count++; | |
StartString = SubString; | |
} | |
gBS->FreePool (TempStr); | |
} | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
EFIAPI | |
UnixBusDriverBindingStop ( | |
IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
IN EFI_HANDLE ControllerHandle, | |
IN UINTN NumberOfChildren, | |
IN EFI_HANDLE *ChildHandleBuffer | |
) | |
/*++ | |
Routine Description: | |
Arguments: | |
Returns: | |
None | |
--*/ | |
// TODO: This - add argument and description to function comment | |
// TODO: ControllerHandle - add argument and description to function comment | |
// TODO: NumberOfChildren - add argument and description to function comment | |
// TODO: ChildHandleBuffer - add argument and description to function comment | |
// TODO: EFI_SUCCESS - add return value to function comment | |
// TODO: EFI_DEVICE_ERROR - add return value to function comment | |
// TODO: EFI_SUCCESS - add return value to function comment | |
{ | |
EFI_STATUS Status; | |
UINTN Index; | |
BOOLEAN AllChildrenStopped; | |
EFI_UNIX_IO_PROTOCOL *UnixIo; | |
UNIX_BUS_DEVICE *UnixBusDevice; | |
UNIX_IO_DEVICE *UnixDevice; | |
EFI_UNIX_THUNK_PROTOCOL *UnixThunk; | |
// | |
// Complete all outstanding transactions to Controller. | |
// Don't allow any new transaction to Controller to be started. | |
// | |
if (NumberOfChildren == 0) { | |
// | |
// Close the bus driver | |
// | |
Status = gBS->OpenProtocol ( | |
ControllerHandle, | |
&gUnixBusDriverGuid, | |
(VOID **)&UnixBusDevice, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
); | |
if (EFI_ERROR (Status)) { | |
return Status; | |
} | |
gBS->UninstallMultipleProtocolInterfaces ( | |
ControllerHandle, | |
&gUnixBusDriverGuid, | |
UnixBusDevice, | |
NULL | |
); | |
FreeUnicodeStringTable (UnixBusDevice->ControllerNameTable); | |
gBS->FreePool (UnixBusDevice); | |
gBS->CloseProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
This->DriverBindingHandle, | |
ControllerHandle | |
); | |
gBS->CloseProtocol ( | |
ControllerHandle, | |
&gEfiDevicePathProtocolGuid, | |
This->DriverBindingHandle, | |
ControllerHandle | |
); | |
return EFI_SUCCESS; | |
} | |
AllChildrenStopped = TRUE; | |
for (Index = 0; Index < NumberOfChildren; Index++) { | |
Status = gBS->OpenProtocol ( | |
ChildHandleBuffer[Index], | |
&gEfiUnixIoProtocolGuid, | |
(VOID **)&UnixIo, | |
This->DriverBindingHandle, | |
ControllerHandle, | |
EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
); | |
if (!EFI_ERROR (Status)) { | |
UnixDevice = UNIX_IO_DEVICE_FROM_THIS (UnixIo); | |
Status = gBS->CloseProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
This->DriverBindingHandle, | |
UnixDevice->Handle | |
); | |
Status = gBS->UninstallMultipleProtocolInterfaces ( | |
UnixDevice->Handle, | |
&gEfiDevicePathProtocolGuid, | |
UnixDevice->DevicePath, | |
&gEfiUnixIoProtocolGuid, | |
&UnixDevice->UnixIo, | |
NULL | |
); | |
if (EFI_ERROR (Status)) { | |
gBS->OpenProtocol ( | |
ControllerHandle, | |
&gEfiUnixThunkProtocolGuid, | |
(VOID **) &UnixThunk, | |
This->DriverBindingHandle, | |
UnixDevice->Handle, | |
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER | |
); | |
} else { | |
// | |
// Close the child handle | |
// | |
FreeUnicodeStringTable (UnixDevice->ControllerNameTable); | |
gBS->FreePool (UnixDevice); | |
} | |
} | |
if (EFI_ERROR (Status)) { | |
AllChildrenStopped = FALSE; | |
} | |
} | |
if (!AllChildrenStopped) { | |
return EFI_DEVICE_ERROR; | |
} | |
return EFI_SUCCESS; | |
} | |
EFI_DEVICE_PATH_PROTOCOL * | |
UnixBusCreateDevicePath ( | |
IN EFI_DEVICE_PATH_PROTOCOL *RootDevicePath, | |
IN EFI_GUID *Guid, | |
IN UINT16 InstanceNumber | |
) | |
/*++ | |
Routine Description: | |
Create a device path node using Guid and InstanceNumber and append it to | |
the passed in RootDevicePath | |
Arguments: | |
RootDevicePath - Root of the device path to return. | |
Guid - GUID to use in vendor device path node. | |
InstanceNumber - Instance number to use in the vendor device path. This | |
argument is needed to make sure each device path is unique. | |
Returns: | |
EFI_DEVICE_PATH_PROTOCOL | |
--*/ | |
{ | |
UNIX_VENDOR_DEVICE_PATH_NODE DevicePath; | |
DevicePath.VendorDevicePath.Header.Type = HARDWARE_DEVICE_PATH; | |
DevicePath.VendorDevicePath.Header.SubType = HW_VENDOR_DP; | |
SetDevicePathNodeLength (&DevicePath.VendorDevicePath.Header, sizeof (UNIX_VENDOR_DEVICE_PATH_NODE)); | |
// | |
// The GUID defines the Class | |
// | |
CopyMem (&DevicePath.VendorDevicePath.Guid, Guid, sizeof (EFI_GUID)); | |
// | |
// Add an instance number so we can make sure there are no Device Path | |
// duplication. | |
// | |
DevicePath.Instance = InstanceNumber; | |
return AppendDevicePathNode ( | |
RootDevicePath, | |
(EFI_DEVICE_PATH_PROTOCOL *) &DevicePath | |
); | |
} |