From 420fc8e58490353b1758537cd2ea0ebf7bdd0bc6 Mon Sep 17 00:00:00 2001 From: klu2 Date: Wed, 27 Jun 2007 05:46:08 +0000 Subject: [PATCH] Add WinNtBusDriverDxe into Nt32Pkg. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2775 6f19259b-4bc3-4df7-8a09-765794883524 --- Nt32Pkg/Nt32.dsc | 5 +- Nt32Pkg/Nt32Pkg.dec | 6 +- Nt32Pkg/WinNtBusDriverDxe/ComponentName.c | 223 ++++++ Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c | 769 +++++++++++++++++++ Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h | 322 ++++++++ Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf | 146 ++++ Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa | 186 +++++ 7 files changed, 1652 insertions(+), 5 deletions(-) create mode 100644 Nt32Pkg/WinNtBusDriverDxe/ComponentName.c create mode 100644 Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c create mode 100644 Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h create mode 100644 Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf create mode 100644 Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa diff --git a/Nt32Pkg/Nt32.dsc b/Nt32Pkg/Nt32.dsc index 5137f6398f..83a8dd0f51 100644 --- a/Nt32Pkg/Nt32.dsc +++ b/Nt32Pkg/Nt32.dsc @@ -376,7 +376,7 @@ # ################################################################################ -[PcdsDynamic.DEFAULT] +[PcdsDynamic.common] PcdFlashNvStorageFtwSpareBase|gEfiGenericPlatformTokenSpaceGuid|0x0 PcdFlashNvStorageVariableSize|gEfiGenericPlatformTokenSpaceGuid|0x0 PcdWinNtCpuSpeed|gEfiNt32PkgTokenSpaceGuid|L"3000"|8 @@ -404,4 +404,5 @@ $(WORKSPACE)\Nt32Pkg\WinNtThunkDxe\WinNtThunk.inf $(WORKSPACE)\Nt32Pkg\WinNtThunkPPIToProtocolPeim\WinNtThunkPPIToProtocolPeim.inf $(WORKSPACE)\Nt32Pkg\WinNtAutoScanPeim\WinNtAutoScan.inf - $(WORKSPACE)\Nt32Pkg\WinNtBlockIoDxe\WinNtBlockIo.inf \ No newline at end of file + $(WORKSPACE)\Nt32Pkg\WinNtBlockIoDxe\WinNtBlockIo.inf + $(WORKSPACE)\Nt32Pkg\WinNtBusDriverDxe\WinNtBusDriver.inf \ No newline at end of file diff --git a/Nt32Pkg/Nt32Pkg.dec b/Nt32Pkg/Nt32Pkg.dec index 92de12e0ef..99196bd48b 100644 --- a/Nt32Pkg/Nt32Pkg.dec +++ b/Nt32Pkg/Nt32Pkg.dec @@ -99,12 +99,12 @@ # ################################################################################ -[PcdFixedAtBuild.common] +[PcdsFixedAtBuild.common] PcdWinNtBootMode|0x00001006|gEfiNt32PkgTokenSpaceGuid|UINT32|1 PcdWinNtFirmwareVolume|0x00001009|gEfiNt32PkgTokenSpaceGuid|VOID*|L"..\\Fv\\Fv_Recovery.fd" PcdWinNtMemorySizeForSecMain|0x0000100c|gEfiNt32PkgTokenSpaceGuid|VOID*|L"64!64" -[PcdDynamic.common] +[PcdsDynamic.common] PcdWinNtPhysicalDisk|0x00001000|gEfiNt32PkgTokenSpaceGuid|VOID*|L"E:RW;245760;512" PcdWinNtVirtualDisk|0x00001001|gEfiNt32PkgTokenSpaceGuid|VOID*|L"FW;40960;512" PcdWinNtSerialPort|0x00001002|gEfiNt32PkgTokenSpaceGuid|VOID*|L"COM1!COM2" @@ -116,7 +116,7 @@ PcdWinNtConsole|0x0000100a|gEfiNt32PkgTokenSpaceGuid|VOID*|L"Bus Driver Console Window" PcdWinNtGop|0x0000100d|gEfiNt32PkgTokenSpaceGuid|VOID*|L"UGA Window 1!UGA Window 2" -[PcdPatchableInModule.common] +[PcdsPatchableInModule.common] PcdWinNtBootMode|0x00001006|gEfiNt32PkgTokenSpaceGuid|UINT32|1 PcdWinNtFirmwareVolume|0x00001009|gEfiNt32PkgTokenSpaceGuid|VOID*|L"..\\Fv\\Fv_Recovery.fd" PcdWinNtMemorySizeForSecMain|0x0000100c|gEfiNt32PkgTokenSpaceGuid|VOID*|L"64!64" \ No newline at end of file diff --git a/Nt32Pkg/WinNtBusDriverDxe/ComponentName.c b/Nt32Pkg/WinNtBusDriverDxe/ComponentName.c new file mode 100644 index 0000000000..c0ea6e853b --- /dev/null +++ b/Nt32Pkg/WinNtBusDriverDxe/ComponentName.c @@ -0,0 +1,223 @@ +/*++ + +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: + + ComponentName.c + +Abstract: + +--*/ + +// +// The package level header files this module uses +// +#include +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +#include + + +#include "WinNtBusDriver.h" + +// +// EFI Component Name Functions +// +EFI_STATUS +EFIAPI +WinNtBusDriverComponentNameGetDriverName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName + ); + +EFI_STATUS +EFIAPI +WinNtBusDriverComponentNameGetControllerName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName + ); + +// +// EFI Component Name Protocol +// +EFI_COMPONENT_NAME_PROTOCOL gWinNtBusDriverComponentName = { + WinNtBusDriverComponentNameGetDriverName, + WinNtBusDriverComponentNameGetControllerName, + "eng" +}; + +static EFI_UNICODE_STRING_TABLE mWinNtBusDriverNameTable[] = { + { "eng", L"Windows Bus Driver" }, + { NULL , NULL } +}; + +EFI_STATUS +EFIAPI +WinNtBusDriverComponentNameGetDriverName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName + ) +/*++ + + Routine Description: + Retrieves a Unicode string that is the user readable name of the EFI Driver. + + Arguments: + This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance. + Language - A pointer to a three character ISO 639-2 language identifier. + This is the language of the driver name that that the caller + is requesting, and it must match one of the languages specified + in SupportedLanguages. The number of languages supported by a + driver is up to the driver writer. + DriverName - A pointer to the Unicode string to return. This Unicode string + is the name of the driver specified by This in the language + specified by Language. + + Returns: + EFI_SUCCESS - The Unicode string for the Driver specified by This + and the language specified by Language was returned + in DriverName. + EFI_INVALID_PARAMETER - Language is NULL. + EFI_INVALID_PARAMETER - DriverName is NULL. + EFI_UNSUPPORTED - The driver specified by This does not support the + language specified by Language. + +--*/ +{ + return LookupUnicodeString ( + Language, + gWinNtBusDriverComponentName.SupportedLanguages, + mWinNtBusDriverNameTable, + DriverName + ); +} + +EFI_STATUS +EFIAPI +WinNtBusDriverComponentNameGetControllerName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName + ) +/*++ + + Routine Description: + Retrieves a Unicode string that is the user readable name of the controller + that is being managed by an EFI Driver. + + Arguments: + This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance. + ControllerHandle - The handle of a controller that the driver specified by + This is managing. This handle specifies the controller + whose name is to be returned. + ChildHandle - The handle of the child controller to retrieve the name + of. This is an optional parameter that may be NULL. It + will be NULL for device drivers. It will also be NULL + for a bus drivers that wish to retrieve the name of the + bus controller. It will not be NULL for a bus driver + that wishes to retrieve the name of a child controller. + Language - A pointer to a three character ISO 639-2 language + identifier. This is the language of the controller name + that that the caller is requesting, and it must match one + of the languages specified in SupportedLanguages. The + number of languages supported by a driver is up to the + driver writer. + ControllerName - A pointer to the Unicode string to return. This Unicode + string is the name of the controller specified by + ControllerHandle and ChildHandle in the language specified + by Language from the point of view of the driver specified + by This. + + Returns: + EFI_SUCCESS - The Unicode string for the user readable name in the + language specified by Language for the driver + specified by This was returned in DriverName. + EFI_INVALID_PARAMETER - ControllerHandle is not a valid EFI_HANDLE. + EFI_INVALID_PARAMETER - ChildHandle is not NULL and it is not a valid EFI_HANDLE. + EFI_INVALID_PARAMETER - Language is NULL. + EFI_INVALID_PARAMETER - ControllerName is NULL. + EFI_UNSUPPORTED - The driver specified by This is not currently managing + the controller specified by ControllerHandle and + ChildHandle. + EFI_UNSUPPORTED - The driver specified by This does not support the + language specified by Language. + +--*/ +{ + EFI_STATUS Status; + EFI_WIN_NT_IO_PROTOCOL *WinNtIo; + WIN_NT_IO_DEVICE *Private; + + // + // Make sure this driver is currently managing ControllHandle + // + Status = EfiTestManagedDevice ( + ControllerHandle, + gWinNtBusDriverBinding.DriverBindingHandle, + &gEfiWinNtThunkProtocolGuid + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // This is a bus driver, so ChildHandle can not be NULL. + // + if (ChildHandle == NULL) { + return EFI_UNSUPPORTED; + } + + Status = EfiTestChildHandle ( + ControllerHandle, + ChildHandle, + &gEfiWinNtThunkProtocolGuid + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Get our context back + // + Status = gBS->OpenProtocol ( + ChildHandle, + &gEfiWinNtIoProtocolGuid, + &WinNtIo, + gWinNtBusDriverBinding.DriverBindingHandle, + ChildHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + return EFI_UNSUPPORTED; + } + + Private = WIN_NT_IO_DEVICE_FROM_THIS (WinNtIo); + + return LookupUnicodeString ( + Language, + gWinNtBusDriverComponentName.SupportedLanguages, + Private->ControllerNameTable, + ControllerName + ); +} diff --git a/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c new file mode 100644 index 0000000000..999fb0cc5d --- /dev/null +++ b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c @@ -0,0 +1,769 @@ +/*+++ + +Copyright (c) 2006 - 2007, 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: + + WinNtBusDriver.c + +Abstract: + +This following section documents the envirnoment variables for the Win NT +build. These variables are used to define the (virtual) hardware +configuration of the NT environment + +A ! can be used to seperate multiple instances in a variable. Each +instance represents a seperate hardware device. + +EFI_WIN_NT_PHYSICAL_DISKS - maps to drives on your system +EFI_WIN_NT_VIRTUAL_DISKS - maps to a device emulated by a file +EFI_WIN_NT_FILE_SYSTEM - mouts a directory as a file system +EFI_WIN_NT_CONSOLE - make a logical comand line window (only one!) +EFI_WIN_NT_UGA - Builds UGA Windows of Width and Height +EFI_WIN_NT_SERIAL_PORT - maps physical serial ports + + ixed - Fixed disk like a hard drive. + emovable - Removable media like a floppy or CD-ROM. + Read nly - Write protected device. + Read rite - Read write device. + - Decimal number of blocks a device supports. + - Decimal number of bytes per block. + + NT 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_WIN_NT_VIRTUAL_DISKS = + ;;[!...] + + EFI_WIN_NT_PHYSICAL_DISKS = + :;;[!...] + + 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_WIN_NT_VIRTUAL_DISKS=FW;40960;512 + + A 1.44MB emulated floppy with a block size of 1024 would look like: + EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024 + + Physical Disks: These devices use NT to open a real device in your system + + Thus a 120 MB floppy would look like: + EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512 + + Thus a standard CD-ROM floppy would look like: + EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048 + + EFI_WIN_NT_FILE_SYSTEM = + [!...] + + Mounting the two directories C:\FOO and C:\BAR would look like: + EFI_WIN_NT_FILE_SYSTEM=c:\foo!c:\bar + + EFI_WIN_NT_CONSOLE = + + + Declaring a text console window with the title "My EFI Console" woild look like: + EFI_WIN_NT_CONSOLE=My EFI Console + + EFI_WIN_NT_UGA = + [!...] + + Declaring a two UGA windows with resolutions of 800x600 and 1024x768 would look like: + Example : EFI_WIN_NT_UGA=800 600!1024 768 + + EFI_WIN_NT_SERIAL_PORT = + [!...] + + Declaring two serial ports on COM1 and COM2 would look like: + Example : EFI_WIN_NT_SERIAL_PORT=COM1!COM2 + + EFI_WIN_NT_PASS_THROUGH = + ;;; + + 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_WIN_NT_PASS_THROUGH=E000000;0;1;0 + +---*/ + +// +// The package level header files this module uses +// +#include +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "WinNtBusDriver.h" + +extern EFI_GUID gWinNtBusDriverGuid; +// +// DriverBinding protocol global +// +EFI_DRIVER_BINDING_PROTOCOL gWinNtBusDriverBinding = { + WinNtBusDriverBindingSupported, + WinNtBusDriverBindingStart, + WinNtBusDriverBindingStop, + 0xa, + NULL, + NULL +}; + +#define NT_PCD_ARRAY_SIZE (sizeof(mPcdEnvironment)/sizeof(NT_PCD_ENTRY)) + +// +// Table to map NT Environment variable to the GUID that should be in +// device path. +// +static NT_PCD_ENTRY mPcdEnvironment[] = { + PcdToken(PcdWinNtConsole), &gEfiWinNtConsoleGuid, + PcdToken(PcdWinNtGop), &gEfiWinNtGopGuid, + PcdToken(PcdWinNtSerialPort), &gEfiWinNtSerialPortGuid, + PcdToken(PcdWinNtFileSystem), &gEfiWinNtFileSystemGuid, + PcdToken(PcdWinNtVirtualDisk), &gEfiWinNtVirtualDisksGuid, + PcdToken(PcdWinNtPhysicalDisk), &gEfiWinNtPhysicalDisksGuid, + PcdToken(PcdWinNtCpuModel), &gEfiWinNtCPUModelGuid, + PcdToken(PcdWinNtCpuSpeed), &gEfiWinNtCPUSpeedGuid, + PcdToken(PcdWinNtMemorySize), &gEfiWinNtMemoryGuid +}; + +/** + The user Entry Point for module WinNtBusDriver. The user code starts with this function. + + @param[in] ImageHandle The firmware allocated handle for the EFI image. + @param[in] SystemTable A pointer to the EFI System Table. + + @retval EFI_SUCCESS The entry point is executed successfully. + @retval other Some error occurs when executing this entry point. + +**/ +EFI_STATUS +EFIAPI +InitializeWinNtBusDriver( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_STATUS Status; + + // + // Install driver model protocol(s). + // + Status = EfiLibInstallAllDriverProtocols ( + ImageHandle, + SystemTable, + &gWinNtBusDriverBinding, + ImageHandle, + &gWinNtBusDriverComponentName, + NULL, + NULL + ); + ASSERT_EFI_ERROR (Status); + + + return Status; +} + +VOID * +AllocateMemory ( + IN UINTN Size + ) +{ + VOID *Buffer; + + Buffer = AllocatePool (Size); + ASSERT (Buffer != NULL); + + return Buffer; +} + + +EFI_STATUS +EFIAPI +WinNtBusDriverBindingSupported ( + 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_WIN_NT_THUNK_PROTOCOL *WinNtThunk; + 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(WIN_NT_VENDOR_DEVICE_PATH_NODE)) { + return EFI_UNSUPPORTED; + } + + for (Index = 0; Index < NT_PCD_ARRAY_SIZE; Index++) { + if (CompareGuid (&((VENDOR_DEVICE_PATH *) RemainingDevicePath)->Guid, mPcdEnvironment[Index].DevicePathGuid)) { + break; + } + } + + if (Index >= NT_PCD_ARRAY_SIZE) { + return EFI_UNSUPPORTED; + } + } + + // + // Open the IO Abstraction(s) needed to perform the supported test + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiDevicePathProtocolGuid, + &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, + &gEfiWinNtThunkProtocolGuid, + &WinNtThunk, + 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 WinNtThunk we need to make sure it's valid + // + Status = EFI_SUCCESS; + if (WinNtThunk->Signature != EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) { + Status = EFI_UNSUPPORTED; + } + + // + // Close the I/O Abstraction(s) used to perform the supported test + // + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + + return Status; +} + +EFI_STATUS +EFIAPI +WinNtBusDriverBindingStart ( + 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_WIN_NT_THUNK_PROTOCOL *WinNtThunk; + EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; + WIN_NT_BUS_DEVICE *WinNtBusDevice; + WIN_NT_IO_DEVICE *WinNtDevice; + UINTN Index; + CHAR16 *StartString; + CHAR16 *SubString; + UINT16 Count; + UINTN StringSize; + UINT16 ComponentName[MAX_NT_ENVIRNMENT_VARIABLE_LENGTH]; + WIN_NT_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, + &ParentDevicePath, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) { + return Status; + } + + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + &WinNtThunk, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) { + return Status; + } + + if (Status != EFI_ALREADY_STARTED) { + WinNtBusDevice = AllocatePool (sizeof (WIN_NT_BUS_DEVICE)); + if (WinNtBusDevice == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + WinNtBusDevice->Signature = WIN_NT_BUS_DEVICE_SIGNATURE; + WinNtBusDevice->ControllerNameTable = NULL; + + AddUnicodeString ( + "eng", + gWinNtBusDriverComponentName.SupportedLanguages, + &WinNtBusDevice->ControllerNameTable, + L"Windows Bus Controller" + ); + + Status = gBS->InstallMultipleProtocolInterfaces ( + &ControllerHandle, + &gWinNtBusDriverGuid, + WinNtBusDevice, + NULL + ); + if (EFI_ERROR (Status)) { + FreeUnicodeStringTable (WinNtBusDevice->ControllerNameTable); + FreePool (WinNtBusDevice); + 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 < NT_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 = (WIN_NT_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 (WIN_NT_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. + // + WinNtDevice = AllocateMemory (sizeof (WIN_NT_IO_DEVICE)); + if (WinNtDevice == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + WinNtDevice->Handle = NULL; + WinNtDevice->ControllerHandle = ControllerHandle; + WinNtDevice->ParentDevicePath = ParentDevicePath; + + WinNtDevice->WinNtIo.WinNtThunk = WinNtThunk; + + // + // Plus 2 to account for the NULL at the end of the Unicode string + // + StringSize = (UINTN) ((UINT8 *) SubString - (UINT8 *) StartString) + sizeof (CHAR16); + WinNtDevice->WinNtIo.EnvString = AllocateMemory (StringSize); + if (WinNtDevice->WinNtIo.EnvString != NULL) { + CopyMem (WinNtDevice->WinNtIo.EnvString, StartString, StringSize); + } + + WinNtDevice->ControllerNameTable = NULL; + + WinNtThunk->SPrintf (ComponentName, sizeof (ComponentName), L"%s", WinNtDevice->WinNtIo.EnvString); + + WinNtDevice->DevicePath = WinNtBusCreateDevicePath ( + ParentDevicePath, + mPcdEnvironment[Index].DevicePathGuid, + Count + ); + if (WinNtDevice->DevicePath == NULL) { + FreePool (WinNtDevice); + return EFI_OUT_OF_RESOURCES; + } + + AddUnicodeString ( + "eng", + gWinNtBusDriverComponentName.SupportedLanguages, + &WinNtDevice->ControllerNameTable, + ComponentName + ); + + WinNtDevice->WinNtIo.TypeGuid = mPcdEnvironment[Index].DevicePathGuid; + WinNtDevice->WinNtIo.InstanceNumber = Count; + + WinNtDevice->Signature = WIN_NT_IO_DEVICE_SIGNATURE; + + Status = gBS->InstallMultipleProtocolInterfaces ( + &WinNtDevice->Handle, + &gEfiDevicePathProtocolGuid, + WinNtDevice->DevicePath, + &gEfiWinNtIoProtocolGuid, + &WinNtDevice->WinNtIo, + NULL + ); + if (EFI_ERROR (Status)) { + FreeUnicodeStringTable (WinNtDevice->ControllerNameTable); + FreePool (WinNtDevice); + } else { + // + // Open For Child Device + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + &WinNtThunk, + This->DriverBindingHandle, + WinNtDevice->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; + } + + FreePool (TempStr); + } + + return EFI_SUCCESS; +} + + +EFI_STATUS +EFIAPI +WinNtBusDriverBindingStop ( + 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_WIN_NT_IO_PROTOCOL *WinNtIo; + WIN_NT_BUS_DEVICE *WinNtBusDevice; + WIN_NT_IO_DEVICE *WinNtDevice; + EFI_WIN_NT_THUNK_PROTOCOL *WinNtThunk; + + // + // 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, + &gWinNtBusDriverGuid, + &WinNtBusDevice, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + return Status; + } + + gBS->UninstallMultipleProtocolInterfaces ( + ControllerHandle, + &gWinNtBusDriverGuid, + WinNtBusDevice, + NULL + ); + + FreeUnicodeStringTable (WinNtBusDevice->ControllerNameTable); + + FreePool (WinNtBusDevice); + + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + 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], + &gEfiWinNtIoProtocolGuid, + &WinNtIo, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (!EFI_ERROR (Status)) { + + WinNtDevice = WIN_NT_IO_DEVICE_FROM_THIS (WinNtIo); + + Status = gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + This->DriverBindingHandle, + WinNtDevice->Handle + ); + + Status = gBS->UninstallMultipleProtocolInterfaces ( + WinNtDevice->Handle, + &gEfiDevicePathProtocolGuid, + WinNtDevice->DevicePath, + &gEfiWinNtIoProtocolGuid, + &WinNtDevice->WinNtIo, + NULL + ); + + if (EFI_ERROR (Status)) { + gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtThunkProtocolGuid, + (VOID **) &WinNtThunk, + This->DriverBindingHandle, + WinNtDevice->Handle, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER + ); + } else { + // + // Close the child handle + // + FreeUnicodeStringTable (WinNtDevice->ControllerNameTable); + FreePool (WinNtDevice); + } + } + + if (EFI_ERROR (Status)) { + AllChildrenStopped = FALSE; + } + } + + if (!AllChildrenStopped) { + return EFI_DEVICE_ERROR; + } + + return EFI_SUCCESS; +} + +EFI_DEVICE_PATH_PROTOCOL * +WinNtBusCreateDevicePath ( + 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 + +--*/ +{ + WIN_NT_VENDOR_DEVICE_PATH_NODE DevicePath; + + DevicePath.VendorDevicePath.Header.Type = HARDWARE_DEVICE_PATH; + DevicePath.VendorDevicePath.Header.SubType = HW_VENDOR_DP; + SetDevicePathNodeLength (&DevicePath.VendorDevicePath.Header, sizeof (WIN_NT_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 + ); +} diff --git a/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h new file mode 100644 index 0000000000..ec3e22770b --- /dev/null +++ b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h @@ -0,0 +1,322 @@ +/*++ + +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: + + WinNtBusDriver.h + +Abstract: + +This following section documents the envirnoment variables for the Win NT +build. These variables are used to define the (virtual) hardware +configuration of the NT environment + +A ! can be used to seperate multiple instances in a variable. Each +instance represents a seperate hardware device. + +EFI_WIN_NT_PHYSICAL_DISKS - maps to drives on your system +EFI_WIN_NT_VIRTUAL_DISKS - maps to a device emulated by a file +EFI_WIN_NT_FILE_SYSTEM - mouts a directory as a file system +EFI_WIN_NT_CONSOLE - make a logical comand line window (only one!) +EFI_WIN_NT_UGA - Builds UGA Windows of Width and Height +EFI_WIN_NT_SERIAL_PORT - maps physical serial ports +EFI_WIN_NT_PASS_THRU - associates a device with our PCI support + + ixed - Fixed disk like a hard drive. + emovable - Removable media like a floppy or CD-ROM. + Read nly - Write protected device. + Read rite - Read write device. + - Decimal number of blocks a device supports. + - Decimal number of bytes per block. + + NT 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_WIN_NT_VIRTUAL_DISKS = + ;;[!...] + + EFI_WIN_NT_PHYSICAL_DISKS = + :;;[!...] + + 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_WIN_NT_VIRTUAL_DISKS=FW;40960;512 + + A 1.44MB emulated floppy with a block size of 1024 would look like: + EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024 + + Physical Disks: These devices use NT to open a real device in your system + + Thus a 120 MB floppy would look like: + EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512 + + Thus a standard CD-ROM floppy would look like: + EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048 + + EFI_WIN_NT_FILE_SYSTEM = + [!...] + + Mounting the two directories C:\FOO and C:\BAR would look like: + EFI_WIN_NT_FILE_SYSTEM=c:\foo!c:\bar + + EFI_WIN_NT_CONSOLE = + + + Declaring a text console window with the title "My EFI Console" woild look like: + EFI_WIN_NT_CONSOLE=My EFI Console + + EFI_WIN_NT_UGA = + [!...] + + Declaring a two UGA windows with resolutions of 800x600 and 1024x768 would look like: + Example : EFI_WIN_NT_UGA=800 600!1024 768 + + EFI_WIN_NT_SERIAL_PORT = + [!...] + + Declaring two serial ports on COM1 and COM2 would look like: + Example : EFI_WIN_NT_SERIAL_PORT=COM1!COM2 + + EFI_WIN_NT_PASS_THROUGH = + ;;; + + 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_WIN_NT_PASS_THROUGH=E000000;0;1;0 + +---*/ + +#ifndef __NT_BUS_DRIVER_H__ +#define __NT_BUS_DRIVER_H__ + + +// +// The package level header files this module uses +// +#include +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// WinNt Bus Driver Global Variables +// +extern EFI_DRIVER_BINDING_PROTOCOL gWinNtBusDriverBinding; +extern EFI_COMPONENT_NAME_PROTOCOL gWinNtBusDriverComponentName; + +// +// WinNt Bus Controller Structure +// +#define WIN_NT_BUS_DEVICE_SIGNATURE EFI_SIGNATURE_32 ('N', 'T', 'B', 'D') + +typedef struct { + UINT64 Signature; + EFI_UNICODE_STRING_TABLE *ControllerNameTable; +} WIN_NT_BUS_DEVICE; + +// +// WinNt Child Device Controller Structure +// +#define WIN_NT_IO_DEVICE_SIGNATURE EFI_SIGNATURE_32 ('N', 'T', 'V', 'D') + +typedef struct { + UINT64 Signature; + EFI_HANDLE Handle; + EFI_WIN_NT_IO_PROTOCOL WinNtIo; + EFI_DEVICE_PATH_PROTOCOL *DevicePath; + + // + // Private data about the parent + // + EFI_HANDLE ControllerHandle; + EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; + + EFI_UNICODE_STRING_TABLE *ControllerNameTable; + +} WIN_NT_IO_DEVICE; + +#define WIN_NT_IO_DEVICE_FROM_THIS(a) \ + CR(a, WIN_NT_IO_DEVICE, WinNtIo, WIN_NT_IO_DEVICE_SIGNATURE) + +// +// This is the largest env variable we can parse +// +#define MAX_NT_ENVIRNMENT_VARIABLE_LENGTH 512 + +typedef struct { + UINTN Token; + EFI_GUID *DevicePathGuid; +} NT_PCD_ENTRY; + +typedef struct { + VENDOR_DEVICE_PATH VendorDevicePath; + UINT32 Instance; +} WIN_NT_VENDOR_DEVICE_PATH_NODE; + +EFI_STATUS +EFIAPI +CpuIoInitialize ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + ImageHandle - TODO: add argument description + SystemTable - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +// +// Driver Binding Protocol function prototypes +// +EFI_STATUS +EFIAPI +WinNtBusDriverBindingSupported ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Handle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + Handle - TODO: add argument description + RemainingDevicePath - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +WinNtBusDriverBindingStart ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ParentHandle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + ParentHandle - TODO: add argument description + RemainingDevicePath - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +WinNtBusDriverBindingStop ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Handle, + IN UINTN NumberOfChildren, + IN EFI_HANDLE *ChildHandleBuffer + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + Handle - TODO: add argument description + NumberOfChildren - TODO: add argument description + ChildHandleBuffer - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +// +// WinNt Bus Driver private worker functions +// +EFI_DEVICE_PATH_PROTOCOL * +WinNtBusCreateDevicePath ( + IN EFI_DEVICE_PATH_PROTOCOL *RootDevicePath, + IN EFI_GUID *Guid, + IN UINT16 InstanceNumber + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + RootDevicePath - TODO: add argument description + Guid - TODO: add argument description + InstanceNumber - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + + +#endif diff --git a/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf new file mode 100644 index 0000000000..d33b8c8ceb --- /dev/null +++ b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf @@ -0,0 +1,146 @@ +#/** @file +# Win NT Bus driver +# +# This following section documents the envirnoment variables for the Win NT +# build. These variables are used to define the (virtual) hardware +# configuration of the NT environment +# Copyright (c) 2006 - 2007, 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = WinNtBusDriver + FILE_GUID = BD7E9A27-D6C5-416a-B245-5F507D95B2BD + MODULE_TYPE = UEFI_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeWinNtBusDriver + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 +# +# DRIVER_BINDING = gWinNtBusDriverBinding +# COMPONENT_NAME = gWinNtBusDriverComponentName +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + ComponentName.c + WinNtBusDriver.c + WinNtBusDriver.h + + +################################################################################ +# +# Includes Section - list of Include locations that are required for +# this module. +# +################################################################################ + +[Includes] + $(WORKSPACE)/MdePkg/Include/Library + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + Nt32Pkg/Nt32Pkg.dec + MdePkg/MdePkg.dec + + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + MemoryAllocationLib + DevicePathLib + UefiBootServicesTableLib + BaseMemoryLib + PcdLib + UefiLib + UefiDriverEntryPoint + BaseLib + DebugLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gEfiWinNtCPUSpeedGuid # ALWAYS_CONSUMED + gEfiWinNtCPUModelGuid # ALWAYS_CONSUMED + gEfiWinNtMemoryGuid # ALWAYS_CONSUMED + gEfiWinNtConsoleGuid # ALWAYS_CONSUMED + gEfiWinNtGopGuid # ALWAYS_CONSUMED + gEfiWinNtSerialPortGuid # ALWAYS_CONSUMED + gEfiWinNtFileSystemGuid # ALWAYS_CONSUMED + gEfiWinNtPhysicalDisksGuid # ALWAYS_CONSUMED + gEfiWinNtVirtualDisksGuid # ALWAYS_CONSUMED + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gWinNtBusDriverGuid # PROTOCOL BY_START + gEfiDevicePathProtocolGuid # PROTOCOL BY_START + gEfiWinNtThunkProtocolGuid # PROTOCOL TO_START + gEfiWinNtIoProtocolGuid # PROTOCOL BY_START + + +################################################################################ +# +# Pcd DYNAMIC - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsDynamic.common] + PcdWinNtMemorySize|gEfiNt32PkgTokenSpaceGuid + PcdWinNtCpuSpeed|gEfiNt32PkgTokenSpaceGuid + PcdWinNtCpuModel|gEfiNt32PkgTokenSpaceGuid + PcdWinNtPhysicalDisk|gEfiNt32PkgTokenSpaceGuid + PcdWinNtVirtualDisk|gEfiNt32PkgTokenSpaceGuid + PcdWinNtFileSystem|gEfiNt32PkgTokenSpaceGuid + PcdWinNtSerialPort|gEfiNt32PkgTokenSpaceGuid + PcdWinNtGop|gEfiNt32PkgTokenSpaceGuid + PcdWinNtUga|gEfiNt32PkgTokenSpaceGuid + PcdWinNtConsole|gEfiNt32PkgTokenSpaceGuid + diff --git a/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa new file mode 100644 index 0000000000..2fb7d61aeb --- /dev/null +++ b/Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa @@ -0,0 +1,186 @@ + + + + WinNtBusDriver + UEFI_DRIVER + BD7E9A27-D6C5-416a-B245-5F507D95B2BD + 1.0 + Win NT Bus driver + This following section documents the envirnoment variables for the Win NT + build. These variables are used to define the (virtual) hardware + configuration of the NT environment + Copyright (c) 2006 - 2007, 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 + false + WinNtBusDriver + + + + DebugLib + + + BaseLib + + + UefiDriverModelLib + + + UefiDriverEntryPoint + + + UefiLib + + + PcdLib + + + BaseMemoryLib + + + UefiBootServicesTableLib + + + DevicePathLib + + + MemoryAllocationLib + + + + WinNtBusDriver.h + WinNtBusDriver.c + ComponentName.c + + + + + + + + gEfiWinNtIoProtocolGuid + + + gEfiWinNtThunkProtocolGuid + + + gEfiDevicePathProtocolGuid + + + gWinNtBusDriverGuid + + + + + gEfiWinNtVirtualDisksGuid + + + gEfiWinNtPhysicalDisksGuid + + + gEfiWinNtFileSystemGuid + + + gEfiWinNtSerialPortGuid + + + gEfiWinNtUgaGuid + + + gEfiWinNtGopGuid + + + gEfiWinNtConsoleGuid + + + gEfiWinNtMemoryGuid + + + gEfiWinNtCPUModelGuid + + + gEfiWinNtCPUSpeedGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + gWinNtBusDriverBinding + gWinNtBusDriverComponentName + + + + + PcdWinNtConsole + gEfiEdkNt32PkgTokenSpaceGuid + This PCD declares the title string of the text console window. + such as "My EFI Console". + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtUga + gEfiEdkNt32PkgTokenSpaceGuid + This PCD declares the resolutions for the UGA windows. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtGop + gEfiEdkNt32PkgTokenSpaceGuid + This PCD declares the resolutions for the GOP windows. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtSerialPort + gEfiEdkNt32PkgTokenSpaceGuid + This Pcd declares two serial port for simulated environment. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtFileSystem + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines the windows directory who will be mounted as + harddisk in simulator. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtVirtualDisk + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines the devices which use a file to emulate a hard disk or + removable media device + The item type if this PCD can only be "DYNAMIC". + + + PcdWinNtPhysicalDisk + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines physical disk which will be simualted as a + harddisk in simulator. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtCpuModel + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines simulated CPU model string. + The item type of this PCD can only be "DYNAMIC". + + + PcdWinNtCpuSpeed + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines simulated CPU speed string. + + + PcdWinNtMemorySize + gEfiEdkNt32PkgTokenSpaceGuid + This PCD defines the size of simulated memory size. + The item type of this PCD can only be "DYNAMIC". + + + \ No newline at end of file -- 2.39.2