From 10160456368b728b172f485fce202d1e10f6ee81 Mon Sep 17 00:00:00 2001 From: klu2 Date: Wed, 27 Jun 2007 05:06:50 +0000 Subject: [PATCH 1/1] Add WinNtBlockIoDxe module into Nt32Pkg. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2770 6f19259b-4bc3-4df7-8a09-765794883524 --- Nt32Pkg/Nt32.dsc | 23 +- Nt32Pkg/WinNtBlockIoDxe/ComponentName.c | 201 +++ Nt32Pkg/WinNtBlockIoDxe/DriverConfiguration.c | 343 +++++ Nt32Pkg/WinNtBlockIoDxe/DriverDiagnostics.c | 191 +++ Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c | 1157 +++++++++++++++++ Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.h | 487 +++++++ Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.inf | 120 ++ Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.msa | 89 ++ 8 files changed, 2600 insertions(+), 11 deletions(-) create mode 100644 Nt32Pkg/WinNtBlockIoDxe/ComponentName.c create mode 100644 Nt32Pkg/WinNtBlockIoDxe/DriverConfiguration.c create mode 100644 Nt32Pkg/WinNtBlockIoDxe/DriverDiagnostics.c create mode 100644 Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c create mode 100644 Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.h create mode 100644 Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.inf create mode 100644 Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.msa diff --git a/Nt32Pkg/Nt32.dsc b/Nt32Pkg/Nt32.dsc index 896d38d7a4..5137f6398f 100644 --- a/Nt32Pkg/Nt32.dsc +++ b/Nt32Pkg/Nt32.dsc @@ -152,13 +152,13 @@ UefiDriverEntryPoint|$(WORKSPACE)\MdePkg\Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf EdkGraphicsLib|$(WORKSPACE)\MdeModulePkg\Library/EdkGraphicsLib/EdkGraphicsLib.inf ReportStatusCodeLib|$(WORKSPACE)\MdePkg\Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf - PrintLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePrintLib/EdkDxePrintLib.inf + PrintLib|$(WORKSPACE)\MdePkg\Library/BasePrintLib/BasePrintLib.inf DxeServicesTableLib|$(WORKSPACE)\MdePkg\Library/DxeServicesTableLib/DxeServicesTableLib.inf UefiDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreUefiDecompressLibFromHob/DxeCoreUefiDecompressLibFromHob.inf HiiLib|$(WORKSPACE)\MdePkg\Library/HiiLib/HiiLib.inf UefiBootServicesTableLib|$(WORKSPACE)\MdePkg\Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf DevicePathLib|$(WORKSPACE)\MdePkg\Library/UefiDevicePathLib/UefiDevicePathLib.inf - BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryLib/DxeMemoryLib.inf + BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/BaseMemoryLib/BaseMemoryLib.inf UefiRuntimeLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUefiRuntimeLib/EdkUefiRuntimeLib.inf TianoDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreTianoDecompressLibFromHob/DxeCoreTianoDecompressLibFromHob.inf EdkUsbLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUsbLib/EdkUsbLib.inf @@ -168,7 +168,7 @@ EdkUsbLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUsbLib/EdkUsbLib.inf DebugLib|$(WORKSPACE)\MdePkg\Library/BaseDebugLibNull/BaseDebugLibNull.inf DxeServicesTableLib|$(WORKSPACE)\MdePkg\Library/DxeServicesTableLib/DxeServicesTableLib.inf - PrintLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePrintLib/EdkDxePrintLib.inf + PrintLib|$(WORKSPACE)\MdePkg\Library/BasePrintLib/BasePrintLib.inf EdkScsiLib|$(WORKSPACE)\MdeModulePkg\Library/EdkScsiLib/EdkScsiLib.inf UefiDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreUefiDecompressLibFromHob/DxeCoreUefiDecompressLibFromHob.inf HiiLib|$(WORKSPACE)\MdePkg\Library/HiiLib/HiiLib.inf @@ -176,7 +176,7 @@ HobLib|$(WORKSPACE)\MdePkg\Library/DxeHobLib/DxeHobLib.inf DevicePathLib|$(WORKSPACE)\MdePkg\Library/UefiDevicePathLib/UefiDevicePathLib.inf EdkIfrSupportLib|$(WORKSPACE)\MdeModulePkg\Library/EdkIfrSupportLib/EdkIfrSupportLib.inf - BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryLib/DxeMemoryLib.inf + BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/BaseMemoryLib/BaseMemoryLib.inf EdkPeCoffLoaderLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePeCoffLoaderFromHobLib/EdkDxePeCoffLoaderFromHobLib.inf PcdLib|$(WORKSPACE)\MdePkg\Library/DxePcdLib/DxePcdLib.inf MemoryAllocationLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf @@ -221,13 +221,13 @@ UefiDriverEntryPoint|$(WORKSPACE)\MdePkg\Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf EdkGraphicsLib|$(WORKSPACE)\MdeModulePkg\Library/EdkGraphicsLib/EdkGraphicsLib.inf ReportStatusCodeLib|$(WORKSPACE)\MdePkg\Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf - PrintLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePrintLib/EdkDxePrintLib.inf + PrintLib|$(WORKSPACE)\MdePkg\Library/BasePrintLib/BasePrintLib.inf DxeServicesTableLib|$(WORKSPACE)\MdePkg\Library/DxeServicesTableLib/DxeServicesTableLib.inf UefiDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreUefiDecompressLibFromHob/DxeCoreUefiDecompressLibFromHob.inf HiiLib|$(WORKSPACE)\MdePkg\Library/HiiLib/HiiLib.inf UefiBootServicesTableLib|$(WORKSPACE)\MdePkg\Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf DevicePathLib|$(WORKSPACE)\MdePkg\Library/UefiDevicePathLib/UefiDevicePathLib.inf - BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryLib/DxeMemoryLib.inf + BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/BaseMemoryLib/BaseMemoryLib.inf UefiRuntimeLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUefiRuntimeLib/EdkUefiRuntimeLib.inf TianoDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreTianoDecompressLibFromHob/DxeCoreTianoDecompressLibFromHob.inf EdkUsbLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUsbLib/EdkUsbLib.inf @@ -246,13 +246,13 @@ UefiDriverEntryPoint|$(WORKSPACE)\MdePkg\Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf EdkGraphicsLib|$(WORKSPACE)\MdeModulePkg\Library/EdkGraphicsLib/EdkGraphicsLib.inf ReportStatusCodeLib|$(WORKSPACE)\MdePkg\Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf - PrintLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePrintLib/EdkDxePrintLib.inf + PrintLib|$(WORKSPACE)\MdePkg\Library/BasePrintLib/BasePrintLib.inf DxeServicesTableLib|$(WORKSPACE)\MdePkg\Library/DxeServicesTableLib/DxeServicesTableLib.inf UefiDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreUefiDecompressLibFromHob/DxeCoreUefiDecompressLibFromHob.inf HiiLib|$(WORKSPACE)\MdePkg\Library/HiiLib/HiiLib.inf UefiBootServicesTableLib|$(WORKSPACE)\MdePkg\Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf DevicePathLib|$(WORKSPACE)\MdePkg\Library/UefiDevicePathLib/UefiDevicePathLib.inf - BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryLib/DxeMemoryLib.inf + BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/BaseMemoryLib/BaseMemoryLib.inf TianoDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreTianoDecompressLibFromHob/DxeCoreTianoDecompressLibFromHob.inf EdkUsbLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUsbLib/EdkUsbLib.inf EdkScsiLib|$(WORKSPACE)\MdeModulePkg\Library/EdkScsiLib/EdkScsiLib.inf @@ -286,7 +286,7 @@ EdkUsbLib|$(WORKSPACE)\MdeModulePkg\Library/EdkUsbLib/EdkUsbLib.inf DebugLib|$(WORKSPACE)\MdePkg\Library/BaseDebugLibNull/BaseDebugLibNull.inf DxeServicesTableLib|$(WORKSPACE)\MdePkg\Library/DxeServicesTableLib/DxeServicesTableLib.inf - PrintLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePrintLib/EdkDxePrintLib.inf + PrintLib|$(WORKSPACE)\MdePkg\Library/BasePrintLib/BasePrintLib.inf EdkScsiLib|$(WORKSPACE)\MdeModulePkg\Library/EdkScsiLib/EdkScsiLib.inf UefiDecompressLib|$(WORKSPACE)\MdeModulePkg\Library/DxeCoreUefiDecompressLibFromHob/DxeCoreUefiDecompressLibFromHob.inf HiiLib|$(WORKSPACE)\MdePkg\Library/HiiLib/HiiLib.inf @@ -295,7 +295,7 @@ HobLib|$(WORKSPACE)\MdePkg\Library/DxeHobLib/DxeHobLib.inf DevicePathLib|$(WORKSPACE)\MdePkg\Library/UefiDevicePathLib/UefiDevicePathLib.inf EdkIfrSupportLib|$(WORKSPACE)\MdeModulePkg\Library/EdkIfrSupportLib/EdkIfrSupportLib.inf - BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryLib/DxeMemoryLib.inf + BaseMemoryLib|$(WORKSPACE)\MdePkg\Library/BaseMemoryLib/BaseMemoryLib.inf EdkPeCoffLoaderLib|$(WORKSPACE)\MdeModulePkg\Library/EdkDxePeCoffLoaderFromHobLib/EdkDxePeCoffLoaderFromHobLib.inf PcdLib|$(WORKSPACE)\MdePkg\Library/DxePcdLib/DxePcdLib.inf MemoryAllocationLib|$(WORKSPACE)\MdePkg\Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf @@ -403,4 +403,5 @@ [Components.IA32] $(WORKSPACE)\Nt32Pkg\WinNtThunkDxe\WinNtThunk.inf $(WORKSPACE)\Nt32Pkg\WinNtThunkPPIToProtocolPeim\WinNtThunkPPIToProtocolPeim.inf - $(WORKSPACE)\Nt32Pkg\WinNtAutoScanPeim\WinNtAutoScan.inf \ No newline at end of file + $(WORKSPACE)\Nt32Pkg\WinNtAutoScanPeim\WinNtAutoScan.inf + $(WORKSPACE)\Nt32Pkg\WinNtBlockIoDxe\WinNtBlockIo.inf \ No newline at end of file diff --git a/Nt32Pkg/WinNtBlockIoDxe/ComponentName.c b/Nt32Pkg/WinNtBlockIoDxe/ComponentName.c new file mode 100644 index 0000000000..d18b0e2739 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/ComponentName.c @@ -0,0 +1,201 @@ +/*++ + +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: + +--*/ +#include +#include +#include +#include + +#include "WinNtBlockIo.h" + +// +// EFI Component Name Functions +// +EFI_STATUS +EFIAPI +WinNtBlockIoComponentNameGetDriverName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName + ); + +EFI_STATUS +EFIAPI +WinNtBlockIoComponentNameGetControllerName ( + 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 gWinNtBlockIoComponentName = { + WinNtBlockIoComponentNameGetDriverName, + WinNtBlockIoComponentNameGetControllerName, + "eng" +}; + +static EFI_UNICODE_STRING_TABLE mWinNtBlockIoDriverNameTable[] = { + { "eng", L"Windows Block I/O Driver" }, + { NULL , NULL } +}; + +EFI_STATUS +EFIAPI +WinNtBlockIoComponentNameGetDriverName ( + 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, + gWinNtBlockIoComponentName.SupportedLanguages, + mWinNtBlockIoDriverNameTable, + DriverName + ); +} + +EFI_STATUS +EFIAPI +WinNtBlockIoComponentNameGetControllerName ( + 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_BLOCK_IO_PROTOCOL *BlockIo; + WIN_NT_BLOCK_IO_PRIVATE *Private; + + // + // This is a device driver, so ChildHandle must be NULL. + // + if (ChildHandle != NULL) { + return EFI_UNSUPPORTED; + } + // + // Make sure this driver is currently managing ControllerHandle + // + Status = EfiTestManagedDevice ( + ControllerHandle, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + &gEfiWinNtIoProtocolGuid + ); + if (EFI_ERROR (Status)) { + return EFI_UNSUPPORTED; + } + // + // Get our context back + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiBlockIoProtocolGuid, + &BlockIo, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + return EFI_UNSUPPORTED; + } + + Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo); + + return LookupUnicodeString ( + Language, + gWinNtBlockIoComponentName.SupportedLanguages, + Private->ControllerNameTable, + ControllerName + ); +} diff --git a/Nt32Pkg/WinNtBlockIoDxe/DriverConfiguration.c b/Nt32Pkg/WinNtBlockIoDxe/DriverConfiguration.c new file mode 100644 index 0000000000..1461de8df8 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/DriverConfiguration.c @@ -0,0 +1,343 @@ +/*++ + +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: + + DriverConfiguration.c + +Abstract: + +--*/ +#include +#include +#include +#include +#include + +#include "WinNtBlockIo.h" + +// +// EFI Driver Configuration Functions +// +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationSetOptions ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED *ActionRequired + ); + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationOptionsValid ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL + ); + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationForceDefaults ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN UINT32 DefaultType, + OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED *ActionRequired + ); + +// +// EFI Driver Configuration Protocol +// +EFI_DRIVER_CONFIGURATION_PROTOCOL gWinNtBlockIoDriverConfiguration = { + WinNtBlockIoDriverConfigurationSetOptions, + WinNtBlockIoDriverConfigurationOptionsValid, + WinNtBlockIoDriverConfigurationForceDefaults, + LANGUAGESUPPORTED +}; + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationSetOptions ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED *ActionRequired + ) +/*++ + + Routine Description: + Allows the user to set controller specific options for a controller that a + driver is currently managing. + + Arguments: + This - A pointer to the EFI_DRIVER_CONFIGURATION_ PROTOCOL instance. + ControllerHandle - The handle of the controller to set options on. + ChildHandle - The handle of the child controller to set options on. This + is an optional parameter that may be NULL. It will be NULL + for device drivers, and for a bus drivers that wish to set + options for the bus controller. It will not be NULL for a + bus driver that wishes to set options for one of its child + controllers. + Language - A pointer to a three character ISO 639-2 language identifier. + This is the language of the user interface that should be + presented to the user, 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. + ActionRequired - A pointer to the action that the calling agent is required + to perform when this function returns. See "Related + Definitions" for a list of the actions that the calling + agent is required to perform prior to accessing + ControllerHandle again. + + Returns: + EFI_SUCCESS - The driver specified by This successfully set the + configuration options for the controller specified + by ControllerHandle.. + 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 - ActionRequired is NULL. + EFI_UNSUPPORTED - The driver specified by This does not support setting + configuration options for the controller specified by + ControllerHandle and ChildHandle. + EFI_UNSUPPORTED - The driver specified by This does not support the + language specified by Language. + EFI_DEVICE_ERROR - A device error occurred while attempt to set the + configuration options for the controller specified + by ControllerHandle and ChildHandle. + EFI_OUT_RESOURCES - There are not enough resources available to set the + configuration options for the controller specified + by ControllerHandle and ChildHandle. + +--*/ +{ + EFI_STATUS Status; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + CHAR8 *SupportedLanguage; + + SupportedLanguage = This->SupportedLanguages; + + Status = EFI_UNSUPPORTED; + while (*SupportedLanguage != 0) { + if (AsciiStrnCmp (Language, SupportedLanguage, 3) == 0) { + Status = EFI_SUCCESS; + } + + SupportedLanguage += 3; + } + + if (EFI_ERROR (Status)) { + return Status; + } + + if (ActionRequired == NULL || ControllerHandle == NULL) { + return EFI_INVALID_PARAMETER; + } + + if (ChildHandle != NULL) { + return EFI_UNSUPPORTED; + } + + // + // Validate controller handle + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + &BlockIo, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + + if (!EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle + ); + + return EFI_UNSUPPORTED; + } + + if (Status == EFI_UNSUPPORTED) { + return Status; + } else if (Status != EFI_ALREADY_STARTED) { + return EFI_INVALID_PARAMETER; + } + + *ActionRequired = EfiDriverConfigurationActionNone; + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationOptionsValid ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL + ) +/*++ + + Routine Description: + Tests to see if a controller's current configuration options are valid. + + Arguments: + This - A pointer to the EFI_DRIVER_CONFIGURATION_PROTOCOL instance. + ControllerHandle - The handle of the controller to test if it's current + configuration options are valid. + ChildHandle - The handle of the child controller to test if it's current + configuration options are valid. 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 test the configuration options for the bus controller. + It will not be NULL for a bus driver that wishes to test + configuration options for one of its child controllers. + + Returns: + EFI_SUCCESS - The controller specified by ControllerHandle and + ChildHandle that is being managed by the driver + specified by This has a valid set of configuration + options. + 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_UNSUPPORTED - The driver specified by This is not currently + managing the controller specified by ControllerHandle + and ChildHandle. + EFI_DEVICE_ERROR - The controller specified by ControllerHandle and + ChildHandle that is being managed by the driver + specified by This has an invalid set of configuration + options. + +--*/ +{ + EFI_STATUS Status; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + + if (ChildHandle != NULL) { + return EFI_UNSUPPORTED; + } + + if (ControllerHandle == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // Validate controller handle + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + &BlockIo, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + + if (!EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle + ); + + return EFI_UNSUPPORTED; + } + + if (Status == EFI_UNSUPPORTED) { + return Status; + } else if (Status != EFI_ALREADY_STARTED) { + return EFI_INVALID_PARAMETER; + } + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverConfigurationForceDefaults ( + IN EFI_DRIVER_CONFIGURATION_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN UINT32 DefaultType, + OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED *ActionRequired + ) +/*++ + + Routine Description: + Forces a driver to set the default configuration options for a controller. + + Arguments: + This - A pointer to the EFI_DRIVER_CONFIGURATION_ PROTOCOL instance. + ControllerHandle - The handle of the controller to force default configuration options on. + ChildHandle - The handle of the child controller to force default configuration options on 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 force default configuration options for the bus controller. It will not be NULL for a bus driver that wishes to force default configuration options for one of its child controllers. + DefaultType - The type of default configuration options to force on the controller specified by ControllerHandle and ChildHandle. See Table 9-1 for legal values. A DefaultType of 0x00000000 must be supported by this protocol. + ActionRequired - A pointer to the action that the calling agent is required to perform when this function returns. See "Related Definitions" in Section 9.1for a list of the actions that the calling agent is required to perform prior to accessing ControllerHandle again. + + Returns: + EFI_SUCCESS - The driver specified by This successfully forced the default configuration options on the controller specified by ControllerHandle and ChildHandle. + 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 - ActionRequired is NULL. + EFI_UNSUPPORTED - The driver specified by This does not support forcing the default configuration options on the controller specified by ControllerHandle and ChildHandle. + EFI_UNSUPPORTED - The driver specified by This does not support the configuration type specified by DefaultType. + EFI_DEVICE_ERROR - A device error occurred while attempt to force the default configuration options on the controller specified by ControllerHandle and ChildHandle. + EFI_OUT_RESOURCES - There are not enough resources available to force the default configuration options on the controller specified by ControllerHandle and ChildHandle. + +--*/ +{ + EFI_STATUS Status; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + + if (ChildHandle != NULL) { + return EFI_UNSUPPORTED; + } + + if (ActionRequired == NULL || ControllerHandle == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // Validate controller handle + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + &BlockIo, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + + if (!EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle + ); + + return EFI_UNSUPPORTED; + } + + if (Status == EFI_UNSUPPORTED) { + return Status; + } else if (Status != EFI_ALREADY_STARTED) { + return EFI_INVALID_PARAMETER; + } + + *ActionRequired = EfiDriverConfigurationActionNone; + return EFI_SUCCESS; +} diff --git a/Nt32Pkg/WinNtBlockIoDxe/DriverDiagnostics.c b/Nt32Pkg/WinNtBlockIoDxe/DriverDiagnostics.c new file mode 100644 index 0000000000..b20bdb56c9 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/DriverDiagnostics.c @@ -0,0 +1,191 @@ +/*++ + +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: + + DriverDiagnostics.c + +Abstract: + +--*/ +#include +#include +#include +#include +#include + +#include "WinNtBlockIo.h" + +// +// EFI Driver Diagnostics Functions +// +EFI_STATUS +EFIAPI +WinNtBlockIoDriverDiagnosticsRunDiagnostics ( + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN EFI_DRIVER_DIAGNOSTIC_TYPE DiagnosticType, + IN CHAR8 *Language, + OUT EFI_GUID **ErrorType, + OUT UINTN *BufferSize, + OUT CHAR16 **Buffer + ); + +// +// EFI Driver Diagnostics Protocol +// +EFI_DRIVER_DIAGNOSTICS_PROTOCOL gWinNtBlockIoDriverDiagnostics = { + WinNtBlockIoDriverDiagnosticsRunDiagnostics, + LANGUAGESUPPORTED +}; + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverDiagnosticsRunDiagnostics ( + IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN EFI_DRIVER_DIAGNOSTIC_TYPE DiagnosticType, + IN CHAR8 *Language, + OUT EFI_GUID **ErrorType, + OUT UINTN *BufferSize, + OUT CHAR16 **Buffer + ) +/*++ + + Routine Description: + Runs diagnostics on a controller. + + Arguments: + This - A pointer to the EFI_DRIVER_DIAGNOSTICS_PROTOCOL instance. + ControllerHandle - The handle of the controller to run diagnostics on. + ChildHandle - The handle of the child controller to run diagnostics on + 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 run diagnostics on the bus + controller. It will not be NULL for a bus driver that + wishes to run diagnostics on one of its child controllers. + DiagnosticType - Indicates type of diagnostics to perform on the controller + specified by ControllerHandle and ChildHandle. See + "Related Definitions" for the list of supported types. + Language - A pointer to a three character ISO 639-2 language + identifier. This is the language in which the optional + error message should be returned in Buffer, 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. + ErrorType - A GUID that defines the format of the data returned in + Buffer. + BufferSize - The size, in bytes, of the data returned in Buffer. + Buffer - A buffer that contains a Null-terminated Unicode string + plus some additional data whose format is defined by + ErrorType. Buffer is allocated by this function with + AllocatePool(), and it is the caller's responsibility + to free it with a call to FreePool(). + + Returns: + EFI_SUCCESS - The controller specified by ControllerHandle and + ChildHandle passed the diagnostic. + 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 - ErrorType is NULL. + EFI_INVALID_PARAMETER - BufferType is NULL. + EFI_INVALID_PARAMETER - Buffer is NULL. + EFI_UNSUPPORTED - The driver specified by This does not support + running diagnostics for the controller specified + by ControllerHandle and ChildHandle. + EFI_UNSUPPORTED - The driver specified by This does not support the + type of diagnostic specified by DiagnosticType. + EFI_UNSUPPORTED - The driver specified by This does not support the + language specified by Language. + EFI_OUT_OF_RESOURCES - There are not enough resources available to complete + the diagnostics. + EFI_OUT_OF_RESOURCES - There are not enough resources available to return + the status information in ErrorType, BufferSize, + and Buffer. + EFI_DEVICE_ERROR - The controller specified by ControllerHandle and + ChildHandle did not pass the diagnostic. + +--*/ +{ + EFI_STATUS Status; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + CHAR8 *SupportedLanguage; + + if (Language == NULL || + ErrorType == NULL || + Buffer == NULL || + ControllerHandle == NULL || + BufferSize == NULL) { + + return EFI_INVALID_PARAMETER; + } + + SupportedLanguage = This->SupportedLanguages; + + Status = EFI_UNSUPPORTED; + while (*SupportedLanguage != 0) { + if (AsciiStrnCmp (Language, SupportedLanguage, 3) == 0) { + Status = EFI_SUCCESS; + break; + } + + SupportedLanguage += 3; + } + + if (EFI_ERROR (Status)) { + return EFI_UNSUPPORTED; + } + + *ErrorType = NULL; + *BufferSize = 0; + if (DiagnosticType != EfiDriverDiagnosticTypeStandard) { + *ErrorType = &gEfiBlockIoProtocolGuid; + *BufferSize = 0x60; + Buffer = AllocatePool ((UINTN) (*BufferSize)); + CopyMem (*Buffer, L"Windows Block I/O Driver Diagnostics Failed\n", *BufferSize); + return EFI_DEVICE_ERROR; + } + + // + // Validate controller handle + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + &BlockIo, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + + if (!EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiWinNtIoProtocolGuid, + gWinNtBlockIoDriverBinding.DriverBindingHandle, + ControllerHandle + ); + + return EFI_UNSUPPORTED; + } + + if (Status == EFI_UNSUPPORTED) { + return Status; + } else if (Status != EFI_ALREADY_STARTED) { + return EFI_INVALID_PARAMETER; + } + + return EFI_SUCCESS; +} diff --git a/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c new file mode 100644 index 0000000000..3f32d2028e --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c @@ -0,0 +1,1157 @@ +/*++ + +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: + + WinNtBlockIo.c + +Abstract: + + Produce block IO abstractions for real devices on your PC using Win32 APIs. + The configuration of what devices to mount or emulate comes from NT + environment variables. The variables must be visible to the Microsoft* + Developer Studio for them to work. + + 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 + + + * Other names and brands may be claimed as the property of others. + +--*/ +#include +#include +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include + +#include "WinNtBlockIo.h" + +EFI_DRIVER_BINDING_PROTOCOL gWinNtBlockIoDriverBinding = { + WinNtBlockIoDriverBindingSupported, + WinNtBlockIoDriverBindingStart, + WinNtBlockIoDriverBindingStop, + 0xa, + NULL, + NULL +}; + +/** + The user Entry Point for module WinNtBlockIo. 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 +InitializeWinNtBlockIo( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_STATUS Status; + + // + // Install driver model protocol(s). + // + Status = EfiLibInstallAllDriverProtocols ( + ImageHandle, + SystemTable, + &gWinNtBlockIoDriverBinding, + ImageHandle, + &gWinNtBlockIoComponentName, + NULL, + &gWinNtBlockIoDriverDiagnostics + ); + ASSERT_EFI_ERROR (Status); + + + return Status; +} + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverBindingSupported ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Handle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + + None + +--*/ +// TODO: This - add argument and description to function comment +// TODO: Handle - add argument and description to function comment +// TODO: RemainingDevicePath - add argument and description to function comment +{ + EFI_STATUS Status; + EFI_WIN_NT_IO_PROTOCOL *WinNtIo; + + // + // Open the IO Abstraction(s) needed to perform the supported test + // + Status = gBS->OpenProtocol ( + Handle, + &gEfiWinNtIoProtocolGuid, + &WinNtIo, + This->DriverBindingHandle, + Handle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Make sure the WinNtThunkProtocol is valid + // + Status = EFI_UNSUPPORTED; + if (WinNtIo->WinNtThunk->Signature == EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) { + + // + // Check the GUID to see if this is a handle type the driver supports + // + if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid) || + CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid) ) { + Status = EFI_SUCCESS; + } + } + + // + // Close the I/O Abstraction(s) used to perform the supported test + // + gBS->CloseProtocol ( + Handle, + &gEfiWinNtIoProtocolGuid, + This->DriverBindingHandle, + Handle + ); + + return Status; +} + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverBindingStart ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Handle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + + None + +--*/ +// TODO: This - add argument and description to function comment +// TODO: Handle - add argument and description to function comment +// TODO: RemainingDevicePath - add argument and description to function comment +{ + EFI_STATUS Status; + EFI_WIN_NT_IO_PROTOCOL *WinNtIo; + WIN_NT_RAW_DISK_DEVICE_TYPE DiskType; + UINT16 Buffer[FILENAME_BUFFER_SIZE]; + CHAR16 *Str; + BOOLEAN RemovableMedia; + BOOLEAN WriteProtected; + UINTN NumberOfBlocks; + UINTN BlockSize; + + // + // Grab the protocols we need + // + Status = gBS->OpenProtocol ( + Handle, + &gEfiWinNtIoProtocolGuid, + &WinNtIo, + This->DriverBindingHandle, + Handle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Set DiskType + // + if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid)) { + DiskType = EfiWinNtVirtualDisks; + } else if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid)) { + DiskType = EfiWinNtPhysicalDisks; + } else { + Status = EFI_UNSUPPORTED; + goto Done; + } + + Status = EFI_NOT_FOUND; + Str = WinNtIo->EnvString; + if (DiskType == EfiWinNtVirtualDisks) { + WinNtIo->WinNtThunk->SPrintf ( + Buffer, + sizeof (Buffer), + L"Diskfile%d", + WinNtIo->InstanceNumber + ); + } else { + if (*Str >= 'A' && *Str <= 'Z' || *Str >= 'a' && *Str <= 'z') { + WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\%c:", *Str); + } else { + WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\PHYSICALDRIVE%c", *Str); + } + + Str++; + if (*Str != ':') { + Status = EFI_NOT_FOUND; + goto Done; + } + + Str++; + } + + if (*Str == 'R' || *Str == 'F') { + RemovableMedia = (BOOLEAN) (*Str == 'R'); + Str++; + if (*Str == 'O' || *Str == 'W') { + WriteProtected = (BOOLEAN) (*Str == 'O'); + Str = GetNextElementPastTerminator (Str, ';'); + + NumberOfBlocks = Atoi (Str); + if (NumberOfBlocks != 0) { + Str = GetNextElementPastTerminator (Str, ';'); + BlockSize = Atoi (Str); + if (BlockSize != 0) { + // + // If we get here the variable is valid so do the work. + // + Status = WinNtBlockIoCreateMapping ( + WinNtIo, + Handle, + Buffer, + WriteProtected, + RemovableMedia, + NumberOfBlocks, + BlockSize, + DiskType + ); + + } + } + } + } + +Done: + if (EFI_ERROR (Status)) { + gBS->CloseProtocol ( + Handle, + &gEfiWinNtIoProtocolGuid, + This->DriverBindingHandle, + Handle + ); + } + + return Status; +} + +EFI_STATUS +EFIAPI +WinNtBlockIoDriverBindingStop ( + 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: + + EFI_UNSUPPORTED - TODO: Add description for return value + +--*/ +{ + EFI_BLOCK_IO_PROTOCOL *BlockIo; + EFI_STATUS Status; + WIN_NT_BLOCK_IO_PRIVATE *Private; + + // + // Get our context back + // + Status = gBS->OpenProtocol ( + Handle, + &gEfiBlockIoProtocolGuid, + &BlockIo, + This->DriverBindingHandle, + Handle, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + return EFI_UNSUPPORTED; + } + + Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo); + + // + // BugBug: If we need to kick people off, we need to make Uninstall Close the handles. + // We could pass in our image handle or FLAG our open to be closed via + // Unistall (== to saying any CloseProtocol will close our open) + // + Status = gBS->UninstallMultipleProtocolInterfaces ( + Private->EfiHandle, + &gEfiBlockIoProtocolGuid, + &Private->BlockIo, + NULL + ); + if (!EFI_ERROR (Status)) { + + Status = gBS->CloseProtocol ( + Handle, + &gEfiWinNtIoProtocolGuid, + This->DriverBindingHandle, + Handle + ); + + // + // Shut down our device + // + Private->WinNtThunk->CloseHandle (Private->NtHandle); + + // + // Free our instance data + // + FreeUnicodeStringTable (Private->ControllerNameTable); + + FreePool (Private); + } + + return Status; +} + +STATIC +CHAR16 * +GetNextElementPastTerminator ( + IN CHAR16 *EnvironmentVariable, + IN CHAR16 Terminator + ) +/*++ + +Routine Description: + + Worker function to parse environment variables. + +Arguments: + EnvironmentVariable - Envirnment variable to parse. + + Terminator - Terminator to parse for. + +Returns: + + Pointer to next eliment past the first occurence of Terminator or the '\0' + at the end of the string. + +--*/ +{ + CHAR16 *Ptr; + + for (Ptr = EnvironmentVariable; *Ptr != '\0'; Ptr++) { + if (*Ptr == Terminator) { + Ptr++; + break; + } + } + + return Ptr; +} + +STATIC +EFI_STATUS +WinNtBlockIoCreateMapping ( + IN EFI_WIN_NT_IO_PROTOCOL *WinNtIo, + IN EFI_HANDLE EfiDeviceHandle, + IN CHAR16 *Filename, + IN BOOLEAN ReadOnly, + IN BOOLEAN RemovableMedia, + IN UINTN NumberOfBlocks, + IN UINTN BlockSize, + IN WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + WinNtIo - TODO: add argument description + EfiDeviceHandle - TODO: add argument description + Filename - TODO: add argument description + ReadOnly - TODO: add argument description + RemovableMedia - TODO: add argument description + NumberOfBlocks - TODO: add argument description + BlockSize - TODO: add argument description + DeviceType - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +{ + EFI_STATUS Status; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + WIN_NT_BLOCK_IO_PRIVATE *Private; + UINTN Index; + + WinNtIo->WinNtThunk->SetErrorMode (SEM_FAILCRITICALERRORS); + + Private = AllocatePool (sizeof (WIN_NT_BLOCK_IO_PRIVATE)); + ASSERT (Private != NULL); + + EfiInitializeLock (&Private->Lock, TPL_NOTIFY); + + Private->WinNtThunk = WinNtIo->WinNtThunk; + + Private->Signature = WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE; + Private->LastBlock = NumberOfBlocks - 1; + Private->BlockSize = BlockSize; + + for (Index = 0; Filename[Index] != 0; Index++) { + Private->Filename[Index] = Filename[Index]; + } + + Private->Filename[Index] = 0; + + Private->ReadMode = GENERIC_READ | (ReadOnly ? 0 : GENERIC_WRITE); + Private->ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + + Private->NumberOfBlocks = NumberOfBlocks; + Private->DeviceType = DeviceType; + Private->NtHandle = INVALID_HANDLE_VALUE; + + Private->ControllerNameTable = NULL; + + AddUnicodeString ( + "eng", + gWinNtBlockIoComponentName.SupportedLanguages, + &Private->ControllerNameTable, + Private->Filename + ); + + BlockIo = &Private->BlockIo; + BlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION; + BlockIo->Media = &Private->Media; + BlockIo->Media->BlockSize = Private->BlockSize; + BlockIo->Media->LastBlock = Private->NumberOfBlocks - 1; + BlockIo->Media->MediaId = 0;; + + BlockIo->Reset = WinNtBlockIoResetBlock; + BlockIo->ReadBlocks = WinNtBlockIoReadBlocks; + BlockIo->WriteBlocks = WinNtBlockIoWriteBlocks; + BlockIo->FlushBlocks = WinNtBlockIoFlushBlocks; + + BlockIo->Media->ReadOnly = ReadOnly; + BlockIo->Media->RemovableMedia = RemovableMedia; + BlockIo->Media->LogicalPartition = FALSE; + BlockIo->Media->MediaPresent = TRUE; + BlockIo->Media->WriteCaching = FALSE; + + if (DeviceType == EfiWinNtVirtualDisks) { + BlockIo->Media->IoAlign = 1; + + // + // Create a file to use for a virtual disk even if it does not exist. + // + Private->OpenMode = OPEN_ALWAYS; + } else if (DeviceType == EfiWinNtPhysicalDisks) { + // + // Physical disk and floppy devices require 4 byte alignment. + // + BlockIo->Media->IoAlign = 4; + + // + // You can only open a physical device if it exists. + // + Private->OpenMode = OPEN_EXISTING; + } else { + ASSERT (FALSE); + } + + Private->EfiHandle = EfiDeviceHandle; + Status = WinNtBlockIoOpenDevice (Private); + if (!EFI_ERROR (Status)) { + + Status = gBS->InstallMultipleProtocolInterfaces ( + &Private->EfiHandle, + &gEfiBlockIoProtocolGuid, + &Private->BlockIo, + NULL + ); + if (EFI_ERROR (Status)) { + FreeUnicodeStringTable (Private->ControllerNameTable); + FreePool (Private); + } + + DEBUG ((EFI_D_INIT, "BlockDevice added: %s\n", Filename)); + } + + return Status; +} + +STATIC +EFI_STATUS +WinNtBlockIoOpenDevice ( + WIN_NT_BLOCK_IO_PRIVATE *Private + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +{ + EFI_STATUS Status; + UINT64 FileSize; + UINT64 EndOfFile; + EFI_BLOCK_IO_PROTOCOL *BlockIo; + + BlockIo = &Private->BlockIo; + EfiAcquireLock (&Private->Lock); + + // + // If the device is already opened, close it + // + if (Private->NtHandle != INVALID_HANDLE_VALUE) { + BlockIo->Reset (BlockIo, FALSE); + } + + // + // Open the device + // + Private->NtHandle = Private->WinNtThunk->CreateFile ( + Private->Filename, + Private->ReadMode, + Private->ShareMode, + NULL, + Private->OpenMode, + 0, + NULL + ); + + Status = Private->WinNtThunk->GetLastError (); + + if (Private->NtHandle == INVALID_HANDLE_VALUE) { + DEBUG ((EFI_D_INFO, "PlOpenBlock: Could not open %s, %x\n", Private->Filename, Private->WinNtThunk->GetLastError ())); + BlockIo->Media->MediaPresent = FALSE; + Status = EFI_NO_MEDIA; + goto Done; + } + + if (!BlockIo->Media->MediaPresent) { + // + // BugBug: try to emulate if a CD appears - notify drivers to check it out + // + BlockIo->Media->MediaPresent = TRUE; + EfiReleaseLock (&Private->Lock); + EfiAcquireLock (&Private->Lock); + } + + // + // get the size of the file + // + Status = SetFilePointer64 (Private, 0, &FileSize, FILE_END); + + if (EFI_ERROR (Status)) { + FileSize = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize); + if (Private->DeviceType == EfiWinNtVirtualDisks) { + DEBUG ((EFI_D_ERROR, "PlOpenBlock: Could not get filesize of %s\n", Private->Filename)); + Status = EFI_UNSUPPORTED; + goto Done; + } + } + + if (Private->NumberOfBlocks == 0) { + Private->NumberOfBlocks = DivU64x32 (FileSize, Private->BlockSize); + } + + EndOfFile = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize); + + if (FileSize != EndOfFile) { + // + // file is not the proper size, change it + // + DEBUG ((EFI_D_INIT, "PlOpenBlock: Initializing block device: %hs\n", Private->Filename)); + + // + // first set it to 0 + // + SetFilePointer64 (Private, 0, NULL, FILE_BEGIN); + Private->WinNtThunk->SetEndOfFile (Private->NtHandle); + + // + // then set it to the needed file size (OS will zero fill it) + // + SetFilePointer64 (Private, EndOfFile, NULL, FILE_BEGIN); + Private->WinNtThunk->SetEndOfFile (Private->NtHandle); + } + + DEBUG ((EFI_D_INIT, "%HPlOpenBlock: opened %s%N\n", Private->Filename)); + Status = EFI_SUCCESS; + +Done: + if (EFI_ERROR (Status)) { + if (Private->NtHandle != INVALID_HANDLE_VALUE) { + BlockIo->Reset (BlockIo, FALSE); + } + } + + EfiReleaseLock (&Private->Lock); + return Status; +} + +STATIC +EFI_STATUS +WinNtBlockIoError ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +{ + EFI_BLOCK_IO_PROTOCOL *BlockIo; + EFI_STATUS Status; + BOOLEAN ReinstallBlockIoFlag; + + BlockIo = &Private->BlockIo; + + switch (Private->WinNtThunk->GetLastError ()) { + + case ERROR_NOT_READY: + Status = EFI_NO_MEDIA; + BlockIo->Media->ReadOnly = FALSE; + BlockIo->Media->MediaPresent = FALSE; + ReinstallBlockIoFlag = FALSE; + break; + + case ERROR_WRONG_DISK: + BlockIo->Media->ReadOnly = FALSE; + BlockIo->Media->MediaPresent = TRUE; + BlockIo->Media->MediaId += 1; + ReinstallBlockIoFlag = TRUE; + Status = EFI_MEDIA_CHANGED; + break; + + case ERROR_WRITE_PROTECT: + BlockIo->Media->ReadOnly = TRUE; + ReinstallBlockIoFlag = FALSE; + Status = EFI_WRITE_PROTECTED; + break; + + default: + ReinstallBlockIoFlag = FALSE; + Status = EFI_DEVICE_ERROR; + break; + } + + if (ReinstallBlockIoFlag) { + BlockIo->Reset (BlockIo, FALSE); + + gBS->ReinstallProtocolInterface ( + Private->EfiHandle, + &gEfiBlockIoProtocolGuid, + BlockIo, + BlockIo + ); + } + + return Status; +} + +STATIC +EFI_STATUS +WinNtBlockIoReadWriteCommon ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + IN VOID *Buffer, + IN CHAR8 *CallerName + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + MediaId - TODO: add argument description + Lba - TODO: add argument description + BufferSize - TODO: add argument description + Buffer - TODO: add argument description + CallerName - TODO: add argument description + +Returns: + + EFI_NO_MEDIA - TODO: Add description for return value + EFI_MEDIA_CHANGED - TODO: Add description for return value + EFI_INVALID_PARAMETER - TODO: Add description for return value + EFI_SUCCESS - TODO: Add description for return value + EFI_BAD_BUFFER_SIZE - TODO: Add description for return value + EFI_INVALID_PARAMETER - TODO: Add description for return value + EFI_SUCCESS - TODO: Add description for return value + +--*/ +{ + EFI_STATUS Status; + UINTN BlockSize; + UINT64 LastBlock; + INT64 DistanceToMove; + UINT64 DistanceMoved; + + if (Private->NtHandle == INVALID_HANDLE_VALUE) { + Status = WinNtBlockIoOpenDevice (Private); + if (EFI_ERROR (Status)) { + return Status; + } + } + + if (!Private->Media.MediaPresent) { + DEBUG ((EFI_D_INIT, "%s: No Media\n", CallerName)); + return EFI_NO_MEDIA; + } + + if (Private->Media.MediaId != MediaId) { + return EFI_MEDIA_CHANGED; + } + + if ((UINT32) Buffer % Private->Media.IoAlign != 0) { + return EFI_INVALID_PARAMETER; + } + + // + // Verify buffer size + // + BlockSize = Private->BlockSize; + if (BufferSize == 0) { + DEBUG ((EFI_D_INIT, "%s: Zero length read\n", CallerName)); + return EFI_SUCCESS; + } + + if ((BufferSize % BlockSize) != 0) { + DEBUG ((EFI_D_INIT, "%s: Invalid read size\n", CallerName)); + return EFI_BAD_BUFFER_SIZE; + } + + LastBlock = Lba + (BufferSize / BlockSize) - 1; + if (LastBlock > Private->LastBlock) { + DEBUG ((EFI_D_INIT, "ReadBlocks: Attempted to read off end of device\n")); + return EFI_INVALID_PARAMETER; + } + // + // Seek to End of File + // + DistanceToMove = MultU64x32 (Lba, BlockSize); + Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN); + + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_INIT, "WriteBlocks: SetFilePointer failed\n")); + return WinNtBlockIoError (Private); + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoReadBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + OUT VOID *Buffer + ) +/*++ + + Routine Description: + Read BufferSize bytes from Lba into Buffer. + + Arguments: + This - Protocol instance pointer. + MediaId - Id of the media, changes every time the media is replaced. + Lba - The starting Logical Block Address to read from + BufferSize - Size of Buffer, must be a multiple of device block size. + Buffer - Buffer containing read data + + Returns: + EFI_SUCCESS - The data was read correctly from the device. + EFI_DEVICE_ERROR - The device reported an error while performing the read. + EFI_NO_MEDIA - There is no media in the device. + EFI_MEDIA_CHANGED - The MediaId does not matched the current device. + EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the + device. + EFI_INVALID_PARAMETER - The read request contains device addresses that are not + valid for the device. + +--*/ +{ + WIN_NT_BLOCK_IO_PRIVATE *Private; + BOOL Flag; + EFI_STATUS Status; + DWORD BytesRead; + EFI_TPL OldTpl; + + OldTpl = gBS->RaiseTPL (TPL_CALLBACK); + + Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This); + + Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtReadBlocks"); + if (EFI_ERROR (Status)) { + goto Done; + } + + Flag = Private->WinNtThunk->ReadFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesRead, NULL); + if (!Flag || (BytesRead != BufferSize)) { + DEBUG ((EFI_D_INIT, "ReadBlocks: ReadFile failed. (%d)\n", Private->WinNtThunk->GetLastError ())); + Status = WinNtBlockIoError (Private); + goto Done; + } + + // + // If we wrote then media is present. + // + This->Media->MediaPresent = TRUE; + Status = EFI_SUCCESS; + +Done: + gBS->RestoreTPL (OldTpl); + return Status; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoWriteBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + IN VOID *Buffer + ) +/*++ + + Routine Description: + Write BufferSize bytes from Lba into Buffer. + + Arguments: + This - Protocol instance pointer. + MediaId - Id of the media, changes every time the media is replaced. + Lba - The starting Logical Block Address to read from + BufferSize - Size of Buffer, must be a multiple of device block size. + Buffer - Buffer containing read data + + Returns: + EFI_SUCCESS - The data was written correctly to the device. + EFI_WRITE_PROTECTED - The device can not be written to. + EFI_DEVICE_ERROR - The device reported an error while performing the write. + EFI_NO_MEDIA - There is no media in the device. + EFI_MEDIA_CHNAGED - The MediaId does not matched the current device. + EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the + device. + EFI_INVALID_PARAMETER - The write request contains a LBA that is not + valid for the device. + +--*/ +{ + WIN_NT_BLOCK_IO_PRIVATE *Private; + UINTN BytesWritten; + BOOL Flag; + EFI_STATUS Status; + EFI_TPL OldTpl; + + OldTpl = gBS->RaiseTPL (TPL_CALLBACK); + + Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This); + + Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtWriteBlocks"); + if (EFI_ERROR (Status)) { + goto Done; + } + + Flag = Private->WinNtThunk->WriteFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesWritten, NULL); + if (!Flag || (BytesWritten != BufferSize)) { + DEBUG ((EFI_D_INIT, "ReadBlocks: WriteFile failed. (%d)\n", Private->WinNtThunk->GetLastError ())); + Status = WinNtBlockIoError (Private); + goto Done; + } + + // + // If the write succeeded, we are not write protected and media is present. + // + This->Media->MediaPresent = TRUE; + This->Media->ReadOnly = FALSE; + Status = EFI_SUCCESS; + +Done: + gBS->RestoreTPL (OldTpl); + return Status; + +} + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoFlushBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This + ) +/*++ + + Routine Description: + Flush the Block Device. + + Arguments: + This - Protocol instance pointer. + + Returns: + EFI_SUCCESS - All outstanding data was written to the device + EFI_DEVICE_ERROR - The device reported an error while writting back the data + EFI_NO_MEDIA - There is no media in the device. + +--*/ +{ + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoResetBlock ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN BOOLEAN ExtendedVerification + ) +/*++ + + Routine Description: + Reset the Block Device. + + Arguments: + This - Protocol instance pointer. + ExtendedVerification - Driver may perform diagnostics on reset. + + Returns: + EFI_SUCCESS - The device was reset. + EFI_DEVICE_ERROR - The device is not functioning properly and could + not be reset. + +--*/ +{ + WIN_NT_BLOCK_IO_PRIVATE *Private; + EFI_TPL OldTpl; + + OldTpl = gBS->RaiseTPL (TPL_CALLBACK); + + Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This); + + if (Private->NtHandle != INVALID_HANDLE_VALUE) { + Private->WinNtThunk->CloseHandle (Private->NtHandle); + Private->NtHandle = INVALID_HANDLE_VALUE; + } + + gBS->RestoreTPL (OldTpl); + + return EFI_SUCCESS; +} + +UINTN +Atoi ( + CHAR16 *String + ) +/*++ + +Routine Description: + + Convert a unicode string to a UINTN + +Arguments: + + String - Unicode string. + +Returns: + + UINTN of the number represented by String. + +--*/ +{ + UINTN Number; + CHAR16 *Str; + + // + // skip preceeding white space + // + Str = String; + while ((*Str) && (*Str == ' ')) { + Str++; + } + // + // Convert ot a Number + // + Number = 0; + while (*Str != '\0') { + if ((*Str >= '0') && (*Str <= '9')) { + Number = (Number * 10) +*Str - '0'; + } else { + break; + } + + Str++; + } + + return Number; +} + +EFI_STATUS +SetFilePointer64 ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private, + IN INT64 DistanceToMove, + OUT UINT64 *NewFilePointer, + IN DWORD MoveMethod + ) +/*++ + +This function extends the capability of SetFilePointer to accept 64 bit parameters + +--*/ +// TODO: function comment is missing 'Routine Description:' +// TODO: function comment is missing 'Arguments:' +// TODO: function comment is missing 'Returns:' +// TODO: Private - add argument and description to function comment +// TODO: DistanceToMove - add argument and description to function comment +// TODO: NewFilePointer - add argument and description to function comment +// TODO: MoveMethod - add argument and description to function comment +{ + EFI_STATUS Status; + LARGE_INTEGER LargeInt; + UINT32 ErrorCode; + + LargeInt.QuadPart = DistanceToMove; + Status = EFI_SUCCESS; + + LargeInt.LowPart = Private->WinNtThunk->SetFilePointer ( + Private->NtHandle, + LargeInt.LowPart, + &LargeInt.HighPart, + MoveMethod + ); + + if (LargeInt.LowPart == -1 && + (ErrorCode = Private->WinNtThunk->GetLastError ()) != NO_ERROR) { + Status = EFI_INVALID_PARAMETER; + } + + if (NewFilePointer != NULL) { + *NewFilePointer = LargeInt.QuadPart; + } + + return Status; +} diff --git a/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.h b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.h new file mode 100644 index 0000000000..f4ec37c098 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.h @@ -0,0 +1,487 @@ +/*++ + +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: + + WinNtBlockIo.h + +Abstract: + + Produce block IO abstractions for real devices on your PC using Win32 APIs. + The configuration of what devices to mount or emulate comes from NT + environment variables. The variables must be visible to the Microsoft* + Developer Studio for them to work. + + * Other names and brands may be claimed as the property of others. + +--*/ + +#ifndef _WIN_NT_BLOCK_IO_H_ +#define _WIN_NT_BLOCK_IO_H_ + +#include +#include +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include + +#define FILENAME_BUFFER_SIZE 80 + +// +// Language supported for driverconfiguration protocol +// +#define LANGUAGESUPPORTED "eng" + +typedef enum { + EfiWinNtVirtualDisks, + EfiWinNtPhysicalDisks, + EifWinNtMaxTypeDisks +} WIN_NT_RAW_DISK_DEVICE_TYPE; + +#define WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE EFI_SIGNATURE_32 ('N', 'T', 'b', 'k') +typedef struct { + UINTN Signature; + + EFI_LOCK Lock; + + CHAR16 Filename[FILENAME_BUFFER_SIZE]; + UINTN ReadMode; + UINTN ShareMode; + UINTN OpenMode; + + HANDLE NtHandle; + WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType; + + UINT64 LastBlock; + UINTN BlockSize; + UINT64 NumberOfBlocks; + + EFI_HANDLE EfiHandle; + EFI_BLOCK_IO_PROTOCOL BlockIo; + EFI_BLOCK_IO_MEDIA Media; + + EFI_UNICODE_STRING_TABLE *ControllerNameTable; + + EFI_WIN_NT_THUNK_PROTOCOL *WinNtThunk; + +} WIN_NT_BLOCK_IO_PRIVATE; + +#define WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS(a) \ + CR(a, WIN_NT_BLOCK_IO_PRIVATE, BlockIo, WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE) + +#define LIST_BUFFER_SIZE 512 + +// +// Block I/O Global Variables +// +extern EFI_DRIVER_BINDING_PROTOCOL gWinNtBlockIoDriverBinding; +extern EFI_COMPONENT_NAME_PROTOCOL gWinNtBlockIoComponentName; +extern EFI_DRIVER_CONFIGURATION_PROTOCOL gWinNtBlockIoDriverConfiguration; +extern EFI_DRIVER_DIAGNOSTICS_PROTOCOL gWinNtBlockIoDriverDiagnostics; + +// +// EFI Driver Binding Functions +// +EFI_STATUS +EFIAPI +WinNtBlockIoDriverBindingSupported ( + 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 +WinNtBlockIoDriverBindingStart ( + 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 +WinNtBlockIoDriverBindingStop ( + 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 + +--*/ +; + +// +// Block IO protocol member functions +// +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoReadBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + OUT VOID *Buffer + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + MediaId - TODO: add argument description + Lba - TODO: add argument description + BufferSize - TODO: add argument description + Buffer - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoWriteBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + IN VOID *Buffer + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + MediaId - TODO: add argument description + Lba - TODO: add argument description + BufferSize - TODO: add argument description + Buffer - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoFlushBlocks ( + IN EFI_BLOCK_IO_PROTOCOL *This + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +EFIAPI +WinNtBlockIoResetBlock ( + IN EFI_BLOCK_IO_PROTOCOL *This, + IN BOOLEAN ExtendedVerification + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + ExtendedVerification - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +// +// Private Worker functions +// +STATIC +EFI_STATUS +WinNtBlockIoCreateMapping ( + IN EFI_WIN_NT_IO_PROTOCOL *WinNtIo, + IN EFI_HANDLE EfiDeviceHandle, + IN CHAR16 *Filename, + IN BOOLEAN ReadOnly, + IN BOOLEAN RemovableMedia, + IN UINTN NumberOfBlocks, + IN UINTN BlockSize, + IN WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + WinNtIo - TODO: add argument description + EfiDeviceHandle - TODO: add argument description + Filename - TODO: add argument description + ReadOnly - TODO: add argument description + RemovableMedia - TODO: add argument description + NumberOfBlocks - TODO: add argument description + BlockSize - TODO: add argument description + DeviceType - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +WinNtBlockIoReadWriteCommon ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private, + IN UINT32 MediaId, + IN EFI_LBA Lba, + IN UINTN BufferSize, + IN VOID *Buffer, + IN CHAR8 *CallerName + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + MediaId - TODO: add argument description + Lba - TODO: add argument description + BufferSize - TODO: add argument description + Buffer - TODO: add argument description + CallerName - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +WinNtBlockIoError ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +EFI_STATUS +WinNtBlockIoOpenDevice ( + WIN_NT_BLOCK_IO_PRIVATE *Private + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +STATIC +CHAR16 * +GetNextElementPastTerminator ( + IN CHAR16 *EnvironmentVariable, + IN CHAR16 Terminator + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + EnvironmentVariable - TODO: add argument description + Terminator - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + + + +EFI_STATUS +SetFilePointer64 ( + IN WIN_NT_BLOCK_IO_PRIVATE *Private, + IN INT64 DistanceToMove, + OUT UINT64 *NewFilePointer, + IN DWORD MoveMethod + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Private - TODO: add argument description + DistanceToMove - TODO: add argument description + NewFilePointer - TODO: add argument description + MoveMethod - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +UINTN +Atoi ( + CHAR16 *String + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + String - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +#endif diff --git a/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.inf b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.inf new file mode 100644 index 0000000000..436a22a4b8 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.inf @@ -0,0 +1,120 @@ +#/** @file +# Block Io driver +# +# Produce block IO abstractions for real devices on your PC using Win32 APIs. +# The configuration of what devices to mount or emulate comes from NT +# environment variables. The variables must be visible to the Microsoft* +# Developer Studio for them to work. +# 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 = WinNtBlockIo + FILE_GUID = F479E147-A125-11d4-BCFC-0080C73C8881 + MODULE_TYPE = UEFI_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeWinNtBlockIo + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 +# +# DRIVER_BINDING = gWinNtBlockIoDriverBinding +# COMPONENT_NAME = gWinNtBlockIoComponentName +# DRIVER_DIAG = gWinNtBlockIoDriverDiagnostics +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + DriverDiagnostics.c + DriverConfiguration.c + ComponentName.c + WinNtBlockIo.c + WinNtBlockIo.h + + +################################################################################ +# +# Includes Section - list of Include locations that are required for +# this module. +# +################################################################################ + +[Includes] + $(WORKSPACE)/MdePkgPkg/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 + UefiBootServicesTableLib + BaseMemoryLib + UefiLib + UefiDriverEntryPoint + BaseLib + DebugLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gEfiWinNtPhysicalDisksGuid # SOMETIMES_CONSUMED + gEfiWinNtVirtualDisksGuid # ALWAYS_CONSUMED + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiBlockIoProtocolGuid # PROTOCOL BY_START + gEfiWinNtIoProtocolGuid # PROTOCOL TO_START + diff --git a/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.msa b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.msa new file mode 100644 index 0000000000..afbf8de6d4 --- /dev/null +++ b/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.msa @@ -0,0 +1,89 @@ + + + + WinNtBlockIo + UEFI_DRIVER + F479E147-A125-11d4-BCFC-0080C73C8881 + 1.0 + Block Io driver + Produce block IO abstractions for real devices on your PC using Win32 APIs. + The configuration of what devices to mount or emulate comes from NT + environment variables. The variables must be visible to the Microsoft* + Developer Studio for them to work. + 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 + WinNtBlockIo + + + + DebugLib + + + BaseLib + + + UefiDriverModelLib + + + UefiDriverEntryPoint + + + UefiLib + + + BaseMemoryLib + + + UefiBootServicesTableLib + + + MemoryAllocationLib + + + + WinNtBlockIo.h + WinNtBlockIo.c + ComponentName.c + DriverConfiguration.c + DriverDiagnostics.c + + + + + + + + gEfiWinNtIoProtocolGuid + + + gEfiBlockIoProtocolGuid + + + + + gEfiWinNtVirtualDisksGuid + + + gEfiWinNtPhysicalDisksGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + gWinNtBlockIoDriverBinding + gWinNtBlockIoComponentName + gWinNtBlockIoDriverDiagnostics + + + \ No newline at end of file -- 2.39.2