tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add WinNtBusDriverDxe into Nt32Pkg. 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2775 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
klu2 2007-06-27 05:46:08 +00:00
parent 66b76b194c
commit 420fc8e584
7 changed files with 1652 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Nt32Pkg/Nt32.dsc
View File

@ -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
$(WORKSPACE)\Nt32Pkg\WinNtBlockIoDxe\WinNtBlockIo.inf
$(WORKSPACE)\Nt32Pkg\WinNtBusDriverDxe\WinNtBusDriver.inf

6
Nt32Pkg/Nt32Pkg.dec
View File

@ -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"

223
Nt32Pkg/WinNtBusDriverDxe/ComponentName.c Normal file
View File

@ -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 <Uefi.h>
#include <WinNtDxe.h>
//
// The protocols, PPI and GUID defintions for this module
//
#include <Protocol/WinNtThunk.h>
#include <Protocol/WinNtIo.h>
#include <Protocol/ComponentName.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/DevicePath.h>
#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
);
}

769
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c Normal file
View File

@ -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
<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.
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 =
<F | R><O | W>;<block count>;<block size>[!...]
EFI_WIN_NT_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_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 =
<directory path>[!...]
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 =
<window title>
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 =
<width> <height>[!...]
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 =
<port name>[!...]
Declaring two serial ports on COM1 and COM2 would look like:
Example : EFI_WIN_NT_SERIAL_PORT=COM1!COM2
EFI_WIN_NT_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_WIN_NT_PASS_THROUGH=E000000;0;1;0
---*/
//
// The package level header files this module uses
//
#include <Uefi.h>
#include <WinNtDxe.h>
//
// The protocols, PPI and GUID defintions for this module
//
#include <Protocol/WinNtThunk.h>
#include <Protocol/WinNtIo.h>
#include <Protocol/ComponentName.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/DevicePath.h>
//
// The Library classes this module consumes
//
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <Library/PcdLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#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
);
}

322
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.h Normal file
View File

@ -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
<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.
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 =
<F | R><O | W>;<block count>;<block size>[!...]
EFI_WIN_NT_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_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 =
<directory path>[!...]
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 =
<window title>
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 =
<width> <height>[!...]
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 =
<port name>[!...]
Declaring two serial ports on COM1 and COM2 would look like:
Example : EFI_WIN_NT_SERIAL_PORT=COM1!COM2
EFI_WIN_NT_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_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 <Uefi.h>
#include <WinNtDxe.h>
//
// The protocols, PPI and GUID defintions for this module
//
#include <Protocol/WinNtIo.h>
#include <Protocol/ComponentName.h>
#include <Protocol/WinNtThunk.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/DevicePath.h>
//
// The Library classes this module consumes
//
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <Library/PcdLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
//
// 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

146
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.inf Normal file
View File

@ -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

186
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.msa Normal file
View File

@ -0,0 +1,186 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>WinNtBusDriver</ModuleName>
<ModuleType>UEFI_DRIVER</ModuleType>
<GuidValue>BD7E9A27-D6C5-416a-B245-5F507D95B2BD</GuidValue>
<Version>1.0</Version>
<Abstract>Win NT Bus driver</Abstract>
<Description>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</Description>
<Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>
<License>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.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>WinNtBusDriver</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverModelLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverEntryPoint</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>PcdLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiBootServicesTableLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DevicePathLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>WinNtBusDriver.h</Filename>
<Filename>WinNtBusDriver.c</Filename>
<Filename>ComponentName.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="0fb2aa2d-10d5-40a5-a9dc-060c12a4a3f3"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="BY_START">
<ProtocolCName>gEfiWinNtIoProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="TO_START">
<ProtocolCName>gEfiWinNtThunkProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="BY_START">
<ProtocolCName>gEfiDevicePathProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="BY_START">
<ProtocolCName>gWinNtBusDriverGuid</ProtocolCName>
</Protocol>
</Protocols>
<Guids>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtVirtualDisksGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtPhysicalDisksGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtFileSystemGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtSerialPortGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtUgaGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtGopGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtConsoleGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtMemoryGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtCPUModelGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiWinNtCPUSpeedGuid</GuidCName>
</GuidCNames>
</Guids>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
<Extern>
<DriverBinding>gWinNtBusDriverBinding</DriverBinding>
<ComponentName>gWinNtBusDriverComponentName</ComponentName>
</Extern>
</Externs>
<PcdCoded>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtConsole</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>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".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtUga</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD declares the resolutions for the UGA windows.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtGop</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD declares the resolutions for the GOP windows.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtSerialPort</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This Pcd declares two serial port for simulated environment.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtFileSystem</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD defines the windows directory who will be mounted as
harddisk in simulator.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtVirtualDisk</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>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".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtPhysicalDisk</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD defines physical disk which will be simualted as a
harddisk in simulator.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtCpuModel</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD defines simulated CPU model string.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtCpuSpeed</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD defines simulated CPU speed string.</HelpText>
</PcdEntry>
<PcdEntry PcdItemType="DYNAMIC">
<C_Name>PcdWinNtMemorySize</C_Name>
<TokenSpaceGuidCName>gEfiEdkNt32PkgTokenSpaceGuid</TokenSpaceGuidCName>
<HelpText>This PCD defines the size of simulated memory size.
The item type of this PCD can only be "DYNAMIC".</HelpText>
</PcdEntry>
</PcdCoded>
</ModuleSurfaceArea>