tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-04-07 19:45:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Formalize comments for Protocols and PPIs.

Browse Source 
1. Use doxygen format for Protocol/PPI data structure
2. Remove doxygen comments for function elements in Protocol/Ppi
3. Use doxygen format for data elements in Protocol/Ppi, and add missing comments where necessary
4. PEI Services Table is also updated accordingly.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@6107 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
xli24 2008-10-13 02:54:29 +00:00
parent 66eebcf94f
commit 44717a398f
103 changed files with 576 additions and 1012 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
MdePkg/Include/Pi/PiPeiCis.h
View File

@ -715,109 +715,68 @@ struct _EFI_PEI_SERVICES {
///
/// The table header for the PEI Services Table.
///
EFI_TABLE_HEADER Hdr;
///
/// Installs an interface in the PEI PEIM-to-PEIM
/// Interface (PPI) database by GUID.
///
EFI_PEI_INSTALL_PPI InstallPpi;
///
/// Reinstalls an interface in the PEI PPI database by GUID.
///
EFI_PEI_REINSTALL_PPI ReInstallPpi;
///
/// Locates an interface in the PEI PPI database by GUID.
///
EFI_PEI_LOCATE_PPI LocatePpi;
///
/// Installs the notification service to be called back
/// upon the installation or reinstallation of a given interface.
///
EFI_PEI_NOTIFY_PPI NotifyPpi;
///
/// Returns the present value of the boot mode.
///
EFI_PEI_GET_BOOT_MODE GetBootMode;
///
/// Sets the value of the boot mode.
///
EFI_PEI_SET_BOOT_MODE SetBootMode;
///
/// Returns the pointer to the list of Hand-Off Blocks (HOBs) in memory.
///
EFI_PEI_GET_HOB_LIST GetHobList;
///
/// Abstracts the creation of HOB headers.
///
EFI_PEI_CREATE_HOB CreateHob;
///
/// Discovers instances of firmware volumes in the system.
///
EFI_TABLE_HEADER Hdr;
//
// PPI Functions
//
EFI_PEI_INSTALL_PPI InstallPpi;
EFI_PEI_REINSTALL_PPI ReInstallPpi;
EFI_PEI_LOCATE_PPI LocatePpi;
EFI_PEI_NOTIFY_PPI NotifyPpi;
//
// Boot Mode Functions
//
EFI_PEI_GET_BOOT_MODE GetBootMode;
EFI_PEI_SET_BOOT_MODE SetBootMode;
//
// HOB Functions
//
EFI_PEI_GET_HOB_LIST GetHobList;
EFI_PEI_CREATE_HOB CreateHob;
//
// Firmware Volume Functions
//
EFI_PEI_FFS_FIND_NEXT_VOLUME2 FfsFindNextVolume;
///
/// Discovers instances of firmware files in the system.
///
EFI_PEI_FFS_FIND_NEXT_FILE2 FfsFindNextFile;
///
/// Searches for a section in a firmware file.
///
EFI_PEI_FFS_FIND_SECTION_DATA2 FfsFindSectionData;
///
/// Registers the found memory configuration with the PEI Foundation.
///
EFI_PEI_INSTALL_PEI_MEMORY InstallPeiMemory;
///
/// Allocates memory ranges that are managed by the PEI Foundation.
///
EFI_PEI_ALLOCATE_PAGES AllocatePages;
///
/// Allocate memory ranges that are managed by the PEI Foundation.
///
EFI_PEI_ALLOCATE_POOL AllocatePool;
///
/// Copies the contents of one buffer to another buffer.
///
EFI_PEI_COPY_MEM CopyMem;
///
/// Fills a buffer with a specified value.
///
EFI_PEI_SET_MEM SetMem;
///
/// Provides an interface that a PEIM can call to report a status code.
///
EFI_PEI_REPORT_STATUS_CODE ReportStatusCode;
///
/// Resets the entire platform.
///
EFI_PEI_RESET_SYSTEM ResetSystem;
///
/// Provides an interface that a PEIM can call to execute
/// an I/O transaction. This interface is installed by provider
/// PEIM by copying the interface into the PEI Service table.
///
EFI_PEI_CPU_IO_PPI *CpuIo;
///
/// Provides an interface that a PEIM can call to execute PCI
/// Configuration transactions. This interface is installed by
/// provider PEIM by copying the interface into the EFI_PEI_SERVICES table.
///
EFI_PEI_PCI_CFG2_PPI *PciCfg;
///
/// Discovers firmware files within a volume by name.
///
EFI_PEI_FFS_FIND_BY_NAME FfsFindFileByName;
///
/// Return information about a particular file.
///
EFI_PEI_FFS_GET_FILE_INFO FfsGetFileInfo;
///
/// Return information about a particular volume.
///
EFI_PEI_FFS_GET_VOLUME_INFO FfsGetVolumeInfo;
///
/// Register a driver to be re-loaded when memory is available.
///
EFI_PEI_REGISTER_FOR_SHADOW RegisterForShadow;
//
// PEI Memory Functions
//
EFI_PEI_INSTALL_PEI_MEMORY InstallPeiMemory;
EFI_PEI_ALLOCATE_PAGES AllocatePages;
EFI_PEI_ALLOCATE_POOL AllocatePool;
EFI_PEI_COPY_MEM CopyMem;
EFI_PEI_SET_MEM SetMem;
//
// Status Code
//
EFI_PEI_REPORT_STATUS_CODE ReportStatusCode;
//
// Reset
//
EFI_PEI_RESET_SYSTEM ResetSystem;
//
// (the following interfaces are installed by publishing PEIM)
// I/O Abstractions
//
EFI_PEI_CPU_IO_PPI *CpuIo;
EFI_PEI_PCI_CFG2_PPI *PciCfg;
//
// Future Installed Services
//
EFI_PEI_FFS_FIND_BY_NAME FfsFindFileByName;
EFI_PEI_FFS_GET_FILE_INFO FfsGetFileInfo;
EFI_PEI_FFS_GET_VOLUME_INFO FfsGetVolumeInfo;
EFI_PEI_REGISTER_FOR_SHADOW RegisterForShadow;
};

62
MdePkg/Include/Ppi/CpuIo.h
View File

@ -383,77 +383,27 @@ VOID
/// The perspective of the services is that of the processor, not the bus or system.
///
struct _EFI_PEI_CPU_IO_PPI {
///
/// Collection of memory-access services.
///
EFI_PEI_CPU_IO_PPI_ACCESS Mem;
///
/// Collection of I/O-access services.
///
EFI_PEI_CPU_IO_PPI_ACCESS Io;
///
/// 8-bit I/O read service.
///
EFI_PEI_CPU_IO_PPI_ACCESS Mem; ///< Collection of memory-access services.
EFI_PEI_CPU_IO_PPI_ACCESS Io; ///< Collection of I/O-access services.
EFI_PEI_CPU_IO_PPI_IO_READ8 IoRead8;
///
/// 16-bit I/O read service.
///
EFI_PEI_CPU_IO_PPI_IO_READ16 IoRead16;
///
/// 32-bit I/O read service.
///
EFI_PEI_CPU_IO_PPI_IO_READ32 IoRead32;
///
/// 64-bit I/O read service.
///
EFI_PEI_CPU_IO_PPI_IO_READ64 IoRead64;
///
/// 8-bit I/O write service.
///
EFI_PEI_CPU_IO_PPI_IO_WRITE8 IoWrite8;
///
/// 16-bit I/O write service.
///
EFI_PEI_CPU_IO_PPI_IO_WRITE16 IoWrite16;
///
/// 32-bit I/O write service.
///
EFI_PEI_CPU_IO_PPI_IO_WRITE32 IoWrite32;
///
/// 64-bit I/O write service.
///
EFI_PEI_CPU_IO_PPI_IO_WRITE64 IoWrite64;
///
/// 8-bit memory read service.
///
EFI_PEI_CPU_IO_PPI_MEM_READ8 MemRead8;
///
/// 16-bit memory read service.
///
EFI_PEI_CPU_IO_PPI_MEM_READ16 MemRead16;
///
/// 32-bit memory read service.
///
EFI_PEI_CPU_IO_PPI_MEM_READ32 MemRead32;
///
/// 64-bit memory read service.
///
EFI_PEI_CPU_IO_PPI_MEM_READ64 MemRead64;
///
/// 8-bit memory write service.
///
EFI_PEI_CPU_IO_PPI_MEM_WRITE8 MemWrite8;
///
/// 16-bit memory write service.
///
EFI_PEI_CPU_IO_PPI_MEM_WRITE16 MemWrite16;
///
/// 32-bit memory write service.
///
EFI_PEI_CPU_IO_PPI_MEM_WRITE32 MemWrite32;
///
/// 64-bit memory write service.
///
EFI_PEI_CPU_IO_PPI_MEM_WRITE64 MemWrite64;
};

3
MdePkg/Include/Ppi/Decompress.h
View File

@ -65,9 +65,6 @@ EFI_STATUS
/// compression sections will be ignored.
///
struct _EFI_PEI_DECOMPRESS_PPI {
///
/// Decompress a single compression section in a firmware file.
///
EFI_PEI_DECOMPRESS_DECOMPRESS Decompress;
};

3
MdePkg/Include/Ppi/DxeIpl.h
View File

@ -65,9 +65,6 @@ EFI_STATUS
/// The DXE IPL PPI may use PEI services to locate and load the DXE Foundation.
///
struct _EFI_DXE_IPL_PPI {
///
/// The entry point to the DXE IPL PPI.
///
EFI_DXE_IPL_ENTRY Entry;
};

18
MdePkg/Include/Ppi/FirmwareVolume.h
View File

@ -208,29 +208,11 @@ EFI_STATUS
/// This PPI provides functions for accessing a memory-mapped firmware volume of a specific format.
///
struct _EFI_PEI_FIRMWARE_VOLUME_PPI {
///
/// Process a firmware volume and create a volume handle.
///
EFI_PEI_FV_PROCESS_FV ProcessVolume;
///
/// Find all files of a specific type.
///
EFI_PEI_FV_FIND_FILE_TYPE FindFileByType;
///
/// Find the file with a specific name.
///
EFI_PEI_FV_FIND_FILE_NAME FindFileByName;
///
/// Return the information about a specific file.
///
EFI_PEI_FV_GET_FILE_INFO GetFileInfo;
///
/// Return the firmware volume attributes.
///
EFI_PEI_FV_GET_INFO GetVolumeInfo;
///
/// Find all sections of a specific type.
///
EFI_PEI_FV_FIND_SECTION FindSectionByType;
};

4
MdePkg/Include/Ppi/GuidedSectionExtraction.h
View File

@ -95,10 +95,6 @@ EFI_STATUS
/// therein.
///
struct _EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI {
///
/// Takes the GUIDed section as input and
/// produces the section stream data.
///
EFI_PEI_EXTRACT_GUIDED_SECTION ExtractSection;
};

3
MdePkg/Include/Ppi/LoadFile.h
View File

@ -66,9 +66,6 @@ EFI_STATUS
/// will use this service to launch the known PEI module images.
///
struct _EFI_PEI_LOAD_FILE_PPI {
///
/// Loads a PEIM into memory for subsequent execution.
///
EFI_PEI_LOAD_FILE LoadFile;
};

104
MdePkg/Include/Ppi/Pcd.h
View File

@ -814,107 +814,9 @@ EFI_STATUS
//
// Interface structure for the PCD PPI
//
/**
@par Ppi Description:
This service abstracts the ability to set/get Platform Configuration Database (PCD).
@param SetSku
Sets the SKU value for subsequent calls to set or get PCD token values.
@param Get8
Retrieves an 8-bit value for a given PCD token.
@param Get16
Retrieves an 16-bit value for a given PCD token.
@param Get32
Retrieves an 32-bit value for a given PCD token.
@param Get64
Retrieves an 64-bit value for a given PCD token.
@param GetPtr
Retrieves a pointer to a value for a given PCD token.
@param GetBool
Retrieves an Boolean value for a given PCD token.
@param GetSize
Retrieves the size of the value for a given PCD token.
@param Get8Ex
Retrieves an 8-bit value for a given PCD token and token space.
@param Get16Ex
Retrieves an 16-bit value for a given PCD token and token space.
@param Get32Ex
Retrieves an 32-bit value for a given PCD token and token space.
@param Get64Ex
Retrieves an 64-bit value for a given PCD token and token space.
@param GetPtrEx
Retrieves a pointer to a value for a given PCD token and token space.
@param GetBoolEx
Retrieves an Boolean value for a given PCD token and token space.
@param GetSizeEx
Retrieves the size of the value for a given PCD token and token space.
@param Set8
Sets an 8-bit value for a given PCD token.
@param Set16
Sets an 16-bit value for a given PCD token.
@param Set32
Sets an 32-bit value for a given PCD token.
@param Set64
Sets an 64-bit value for a given PCD token.
@param SetPtr
Sets the buffer of a specified size for a given PCD token.
@param SetBool
Sets an Boolean value for a given PCD token.
@param Set8Ex
Sets an 8-bit value for a given PCD token and token space.
@param Set16Ex
Sets an 16-bit value for a given PCD token and token space.
@param Set32Ex
Sets an 32-bit value for a given PCD token and token space.
@param Set64Ex
Sets an 64-bit value for a given PCD token and token space.
@param SetPtrEx
Sets the buffer of a specified size for a given PCD token and token space.
@param SetBoolEx
Sets an Boolean value for a given PCD token and token space.
@param CallbackOnSet
Specifies a function to be called anytime the value of a designated token is changed.
@param CancelCallback
Cancels a previously set callback function for a particular PCD token number.
@param GetNextToken
Retrieves the next valid PCD token for a given namespace.
@param GetNextTokenSpace
Retrieves the next valid PCD token namespace for a given namespace.
**/
///
/// This service abstracts the ability to set/get Platform Configuration Database (PCD).
///
typedef struct {
PCD_PPI_SET_SKU SetSku;

21
MdePkg/Include/Ppi/PciCfg2.h
View File

@ -153,24 +153,17 @@ EFI_STATUS
IN VOID *ClearBits
);
/**
@par Ppi Description:
The EFI_PEI_PCI_CFG_PPI interfaces are used to abstract accesses to PCI
controllers behind a PCI root bridge controller.
@param Read PCI read services. See the Read() function description.
@param Write PCI write services. See the Write() function description.
@param Modify PCI read-modify-write services. See the Modify() function description.
@param Segment The PCI bus segment which the specified functions will access.
**/
///
/// The EFI_PEI_PCI_CFG_PPI interfaces are used to abstract accesses to PCI
/// controllers behind a PCI root bridge controller.
///
struct _EFI_PEI_PCI_CFG2_PPI {
EFI_PEI_PCI_CFG2_PPI_IO Read;
EFI_PEI_PCI_CFG2_PPI_IO Write;
EFI_PEI_PCI_CFG2_PPI_RW Modify;
///
/// The PCI bus segment which the specified functions will access.
///
UINT16 Segment;
};

6
MdePkg/Include/Ppi/ReadOnlyVariable2.h
View File

@ -107,13 +107,7 @@ EFI_STATUS
/// variable services.
///
struct _EFI_PEI_READ_ONLY_VARIABLE2_PPI {
///
/// A service to read the value of a particular variable using its name.
///
EFI_PEI_GET_VARIABLE2 GetVariable;
///
/// Find the next variable name in the variable store.
///
EFI_PEI_NEXT_VARIABLE_NAME2 NextVariableName;
};

4
MdePkg/Include/Ppi/Reset.h
View File

@ -39,10 +39,6 @@
/// This PPI provides provide a simple reset service.
///
typedef struct {
///
/// A service to reset the entire platform.
/// This function is defined in PiPeicis.h.
///
EFI_PEI_RESET_SYSTEM ResetSystem;
} EFI_PEI_RESET_PPI;

3
MdePkg/Include/Ppi/SecPlatformInformation.h
View File

@ -156,9 +156,6 @@ EFI_STATUS
/// discover where to begin dispatching PEIMs.
///
struct _EFI_SEC_PLATFORM_INFORMATION_PPI {
///
/// Conveys state information out of the SEC phase into PEI.
///
EFI_SEC_PLATFORM_INFORMATION PlatformInformation;
};

4
MdePkg/Include/Ppi/Security2.h
View File

@ -84,10 +84,6 @@ EFI_STATUS
/// trusted.
///
struct _EFI_PEI_SECURITY2_PPI {
///
/// Allows the platform builder to implement a security policy
/// in response to varying file authentication states.
///
EFI_PEI_SECURITY_AUTHENTICATION_STATE AuthenticationState;
};

14
MdePkg/Include/Ppi/Smbus2.h
View File

@ -209,23 +209,9 @@ EFI_STATUS
/// its SMBus controller and the slave devices attached to it.
///
struct _EFI_PEI_SMBUS2_PPI {
///
/// Executes the SMBus operation to an SMBus slave device.
///
EFI_PEI_SMBUS2_PPI_EXECUTE_OPERATION Execute;
///
/// Allows an SMBus 2.0 device(s) to be Address Resolution Protocol (ARP).
///
EFI_PEI_SMBUS2_PPI_ARP_DEVICE ArpDevice;
///
/// Allows a PEIM to retrieve the address that was allocated by the SMBus
/// host controller during enumeration/ARP.
///
EFI_PEI_SMBUS2_PPI_GET_ARP_MAP GetArpMap;
///
/// Allows a driver to register for a callback to the SMBus host
/// controller driver when the bus issues a notification to the bus controller PEIM.
///
EFI_PEI_SMBUS2_PPI_NOTIFY Notify;
///
/// Identifier which uniquely identifies this SMBus controller in a system.

4
MdePkg/Include/Ppi/Stall.h
View File

@ -54,9 +54,7 @@ struct _EFI_PEI_STALL_PPI {
/// The resolution in microseconds of the stall services.
///
UINTN Resolution;
///
/// The actual stall procedure call.
///
EFI_PEI_STALL Stall;
};

4
MdePkg/Include/Ppi/StatusCode.h
View File

@ -36,10 +36,6 @@
/// There can be only one instance of this service in the system.
///
typedef struct {
///
/// Service that allows PEIMs to report status codes.
/// This function is defined in PiPeicis.h.
///
EFI_PEI_REPORT_STATUS_CODE ReportStatusCode;
} EFI_PEI_PROGRESS_CODE_PPI;

4
MdePkg/Include/Ppi/TemporaryRamSupport.h
View File

@ -53,10 +53,6 @@ EFI_STATUS
/// This service abstracts the ability to migrate contents of the platform early memory store.
///
typedef struct {
///
/// Perform the migration of contents of Temporary RAM to Permanent RAM.
/// Terminate the Temporary RAM if it cannot coexist with the Permanent RAM.
///
TEMPORARY_RAM_MIGRATION TemporaryRamMigration;
} TEMPORARY_RAM_SUPPORT_PPI;

23
MdePkg/Include/Protocol/AbsolutePointer.h
View File

@ -176,17 +176,15 @@ EFI_STATUS
);
/**
@par Protocol Description:
The EFI_ABSOLUTE_POINTER_PROTOCOL provides a set of services
for a pointer device that can be used as an input device from an
application written to this specification. The services include
the ability to reset the pointer device, retrieve the state of
the pointer device, and retrieve the capabilities of the pointer
device. In addition certain data items describing the device are
provided.
**/
///
/// The EFI_ABSOLUTE_POINTER_PROTOCOL provides a set of services
/// for a pointer device that can be used as an input device from an
/// application written to this specification. The services include
/// the ability to reset the pointer device, retrieve the state of
/// the pointer device, and retrieve the capabilities of the pointer
/// device. In addition certain data items describing the device are
/// provided.
///
struct _EFI_ABSOLUTE_POINTER_PROTOCOL {
EFI_ABSOLUTE_POINTER_RESET Reset;
EFI_ABSOLUTE_POINTER_GET_STATE GetState;
@ -194,6 +192,9 @@ struct _EFI_ABSOLUTE_POINTER_PROTOCOL {
/// Event to use with WaitForEvent() to wait for input from the pointer device.
///
EFI_EVENT WaitForInput;
///
/// Pointer to EFI_ABSOLUTE_POINTER_MODE data.
///
EFI_ABSOLUTE_POINTER_MODE *Mode;
};

9
MdePkg/Include/Protocol/AcpiTable.h
View File

@ -104,11 +104,10 @@ EFI_STATUS
IN UINTN TableKey
);
/**
@par Protocol Description:
The EFI_ACPI_TABLE_PROTOCOL provides the ability for a component
to install and uninstall ACPI tables from a platform.
**/
///
/// The EFI_ACPI_TABLE_PROTOCOL provides the ability for a component
/// to install and uninstall ACPI tables from a platform.
///
struct _EFI_ACPI_TABLE_PROTOCOL {
EFI_ACPI_TABLE_INSTALL_ACPI_TABLE InstallAcpiTable;
EFI_ACPI_TABLE_UNINSTALL_ACPI_TABLE UninstallAcpiTable;

9
MdePkg/Include/Protocol/Arp.h
View File

@ -249,11 +249,10 @@ EFI_STATUS
IN EFI_EVENT ResolvedEvent OPTIONAL
);
/**
@par Protocol Description:
ARP is used to resolve local network protocol addresses into
network hardware addresses.
**/
///
/// ARP is used to resolve local network protocol addresses into
/// network hardware addresses.
///
struct _EFI_ARP_PROTOCOL {
EFI_ARP_CONFIGURE Configure;
EFI_ARP_ADD Add;

9
MdePkg/Include/Protocol/AuthenticationInfo.h
View File

@ -109,11 +109,10 @@ EFI_STATUS
IN VOID *Buffer
);
/**
@par Protocol Description:
This protocol is used on any device handle to obtain authentication
information associated with the physical or logical device.
**/
///
/// This protocol is used on any device handle to obtain authentication
/// information associated with the physical or logical device.
///
struct _EFI_AUTHENTICATION_INFO_PROTOCOL {
EFI_AUTHENTICATION_PROTOCOL_INFO_GET Get;
EFI_AUTHENTICATION_PROTOCOL_INFO_SET Set;

20
MdePkg/Include/Protocol/Bds.h
View File

@ -55,18 +55,14 @@ VOID
IN EFI_BDS_ARCH_PROTOCOL *This
);
/**
Interface stucture for the BDS Architectural Protocol.
@par Protocol Description:
The EFI_BDS_ARCH_PROTOCOL transfers control from DXE to an operating
system or a system utility. If there are not enough drivers initialized
when this protocol is used to access the required boot device(s), then
this protocol should add drivers to the dispatch queue and return control
back to the dispatcher. Once the required boot devices are available, then
the boot device can be used to load and invoke an OS or a system utility.
**/
///
/// The EFI_BDS_ARCH_PROTOCOL transfers control from DXE to an operating
/// system or a system utility. If there are not enough drivers initialized
/// when this protocol is used to access the required boot device(s), then
/// this protocol should add drivers to the dispatch queue and return control
/// back to the dispatcher. Once the required boot devices are available, then
/// the boot device can be used to load and invoke an OS or a system utility.
///
struct _EFI_BDS_ARCH_PROTOCOL {
EFI_BDS_ENTRY Entry;
};

9
MdePkg/Include/Protocol/Bis.h
View File

@ -397,11 +397,10 @@ EFI_STATUS
OUT EFI_BIS_DATA **SignatureInfo
);
/**
@par Protocol Description:
The EFI_BIS_PROTOCOL is used to check a digital signature of a data block against a digital
certificate for the purpose of an integrity and authorization check.
**/
///
/// The EFI_BIS_PROTOCOL is used to check a digital signature of a data block against a digital
/// certificate for the purpose of an integrity and authorization check.
///
struct _EFI_BIS_PROTOCOL {
EFI_BIS_INITIALIZE Initialize;
EFI_BIS_SHUTDOWN Shutdown;

11
MdePkg/Include/Protocol/BlockIo.h
View File

@ -189,10 +189,9 @@ typedef struct {
///
#define EFI_BLOCK_IO_INTERFACE_REVISION EFI_BLOCK_IO_PROTOCOL_REVISION
/**
@par Protocol Description:
This protocol provides control over block devices.
**/
///
/// This protocol provides control over block devices.
///
struct _EFI_BLOCK_IO_PROTOCOL {
///
/// The revision to which the block IO interface adheres. All future
@ -200,7 +199,9 @@ struct _EFI_BLOCK_IO_PROTOCOL {
/// back wards compatible, it is not the same GUID.
///
UINT64 Revision;
///
/// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
///
EFI_BLOCK_IO_MEDIA *Media;
EFI_BLOCK_RESET Reset;

14
MdePkg/Include/Protocol/BusSpecificDriverOverride.h
View File

@ -57,15 +57,11 @@ EFI_STATUS
IN OUT EFI_HANDLE *DriverImageHandle
);
//
// Interface structure for the Bus Specific Driver Override Protocol
//
/**
@par Protocol Description:
This protocol matches one or more drivers to a controller. This protocol is produced by a bus driver,
and it is installed on the child handles of buses that require a bus specific algorithm for matching
drivers to controllers.
**/
///
/// This protocol matches one or more drivers to a controller. This protocol is produced by a bus driver,
/// and it is installed on the child handles of buses that require a bus specific algorithm for matching
/// drivers to controllers.
///
struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL {
EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER GetDriver;
};

12
MdePkg/Include/Protocol/ComponentName.h
View File

@ -109,14 +109,10 @@ EFI_STATUS
OUT CHAR16 **ControllerName
);
//
// Interface structure for the Component Name Protocol
//
/**
@par Protocol Description:
This protocol is used to retrieve user readable names of drivers
and controllers managed by UEFI Drivers.
**/
///
/// This protocol is used to retrieve user readable names of drivers
/// and controllers managed by UEFI Drivers.
///
struct _EFI_COMPONENT_NAME_PROTOCOL {
EFI_COMPONENT_NAME_GET_DRIVER_NAME GetDriverName;
EFI_COMPONENT_NAME_GET_CONTROLLER_NAME GetControllerName;

12
MdePkg/Include/Protocol/ComponentName2.h
View File

@ -151,14 +151,10 @@ EFI_STATUS
OUT CHAR16 **ControllerName
);
//
// Interface structure for the Component Name2 Protocol
//
/**
@par Protocol Description:
This protocol is used to retrieve user readable names of drivers
and controllers managed by UEFI Drivers.
**/
///
/// This protocol is used to retrieve user readable names of drivers
/// and controllers managed by UEFI Drivers.
///
struct _EFI_COMPONENT_NAME2_PROTOCOL {
EFI_COMPONENT_NAME2_GET_DRIVER_NAME GetDriverName;
EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME GetControllerName;

13
MdePkg/Include/Protocol/Cpu.h
View File

@ -255,13 +255,12 @@ EFI_STATUS
);
/**
@par Protocol Description:
The EFI_CPU_ARCH_PROTOCOL is used to abstract processor-specific functions from the DXE
Foundation. This includes flushing caches, enabling and disabling interrupts, hooking interrupt
vectors and exception vectors, reading internal processor timers, resetting the processor, and
determining the processor frequency.
**/
///
/// The EFI_CPU_ARCH_PROTOCOL is used to abstract processor-specific functions from the DXE
/// Foundation. This includes flushing caches, enabling and disabling interrupts, hooking interrupt
/// vectors and exception vectors, reading internal processor timers, resetting the processor, and
/// determining the processor frequency.
///
struct _EFI_CPU_ARCH_PROTOCOL {
EFI_CPU_FLUSH_DATA_CACHE FlushDataCache;
EFI_CPU_ENABLE_INTERRUPT EnableInterrupt;

10
MdePkg/Include/Protocol/DebugPort.h
View File

@ -113,13 +113,9 @@ EFI_STATUS
IN EFI_DEBUGPORT_PROTOCOL *This
);
//
// DebugPort protocol definition
//
/**
@par Protocol Description:
This protocol provides the communication link between the debug agent and the remote host.
**/
///
/// This protocol provides the communication link between the debug agent and the remote host.
///
struct _EFI_DEBUGPORT_PROTOCOL {
EFI_DEBUGPORT_RESET Reset;
EFI_DEBUGPORT_WRITE Write;

17
MdePkg/Include/Protocol/DebugSupport.h
View File

@ -613,16 +613,15 @@ EFI_STATUS
IN UINT64 Length
);
//
// DebugSupport protocol definition
//
/**
@par Protocol Description:
This protocol provides the services to allow the debug agent to register
callback functions that are called either periodically or when specific
processor exceptions occur.
**/
///
/// This protocol provides the services to allow the debug agent to register
/// callback functions that are called either periodically or when specific
/// processor exceptions occur.
///
struct _EFI_DEBUG_SUPPORT_PROTOCOL {
///
/// Declares the processor architecture for this instance of the EFI Debug Support protocol.
///
EFI_INSTRUCTION_SET_ARCHITECTURE Isa;
EFI_GET_MAXIMUM_PROCESSOR_INDEX GetMaximumProcessorIndex;
EFI_REGISTER_PERIODIC_CALLBACK RegisterPeriodicCallback;

8
MdePkg/Include/Protocol/Decompress.h
View File

@ -109,11 +109,9 @@ EFI_STATUS
IN UINT32 ScratchSize
);
/**
@par Protocol Description:
Provides a decompression service.
**/
///
/// Provides a decompression service.
///
struct _EFI_DECOMPRESS_PROTOCOL {
EFI_DECOMPRESS_GET_INFO GetInfo;
EFI_DECOMPRESS_DECOMPRESS Decompress;

9
MdePkg/Include/Protocol/DeviceIo.h
View File

@ -213,11 +213,10 @@ EFI_STATUS
IN EFI_PHYSICAL_ADDRESS HostAddress
);
/**
@par Protocol Description:
This protocol provides the basic Memory, I/O, and PCI interfaces that
are used to abstract accesses to devices.
**/
///
/// This protocol provides the basic Memory, I/O, and PCI interfaces that
/// are used to abstract accesses to devices.
///
struct _EFI_DEVICE_IO_PROTOCOL {
///
/// Allows reads and writes to memory mapped I/O space.

7
MdePkg/Include/Protocol/DevicePathFromText.h
View File

@ -61,10 +61,9 @@ EFI_DEVICE_PATH_PROTOCOL*
IN CONST CHAR16 *TextDevicePath
);
/**
@par Protocol Description:
This protocol converts text to device paths and device nodes.
**/
///
/// This protocol converts text to device paths and device nodes.
///
typedef struct {
EFI_DEVICE_PATH_FROM_TEXT_NODE ConvertTextToDeviceNode;
EFI_DEVICE_PATH_FROM_TEXT_PATH ConvertTextToDevicePath;

7
MdePkg/Include/Protocol/DevicePathToText.h
View File

@ -72,10 +72,9 @@ CHAR16*
IN BOOLEAN AllowShortcuts
);
/**
@par Protocol Description:
This protocol converts device paths and device nodes to text.
**/
///
/// This protocol converts device paths and device nodes to text.
///
typedef struct {
EFI_DEVICE_PATH_TO_TEXT_NODE ConvertDeviceNodeToText;
EFI_DEVICE_PATH_TO_TEXT_PATH ConvertDevicePathToText;

7
MdePkg/Include/Protocol/DevicePathUtilities.h
View File

@ -170,10 +170,9 @@ BOOLEAN
IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
);
/**
@par Protocol Description:
This protocol is used to creates and manipulates device paths and device nodes.
**/
///
/// This protocol is used to creates and manipulates device paths and device nodes.
///
typedef struct {
EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE GetDevicePathSize;
EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH DuplicateDevicePath;

9
MdePkg/Include/Protocol/Dhcp4.h
View File

@ -411,11 +411,10 @@ EFI_STATUS
OUT EFI_DHCP4_PACKET_OPTION *PacketOptionList[] OPTIONAL
);
/**
@par Protocol Description:
This protocol is used to collect configuration information for the EFI IPv4 Protocol drivers
and to provide DHCPv4 server and PXE boot server discovery services.
**/
///
/// This protocol is used to collect configuration information for the EFI IPv4 Protocol drivers
/// and to provide DHCPv4 server and PXE boot server discovery services.
///
struct _EFI_DHCP4_PROTOCOL {
EFI_DHCP4_GET_MODE_DATA GetModeData;
EFI_DHCP4_CONFIGURE Configure;

7
MdePkg/Include/Protocol/DiskIo.h
View File

@ -98,10 +98,9 @@ EFI_STATUS
///
#define EFI_DISK_IO_INTERFACE_REVISION EFI_DISK_IO_PROTOCOL_REVISION
/**
@par Protocol Description:
This protocol is used to abstract Block I/O interfaces.
**/
///
/// This protocol is used to abstract Block I/O interfaces.
///
struct _EFI_DISK_IO_PROTOCOL {
///
/// The revision to which the disk I/O interface adheres. All future

12
MdePkg/Include/Protocol/DriverBinding.h
View File

@ -108,14 +108,10 @@ EFI_STATUS
IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
);
//
// Interface structure for the ControllerHandle Driver Protocol
//
/**
@par Protocol Description:
This protocol provides the services required to determine if a driver supports a given controller.
If a controller is supported, then it also provides routines to start and stop the controller.
**/
///
/// This protocol provides the services required to determine if a driver supports a given controller.
/// If a controller is supported, then it also provides routines to start and stop the controller.
///
struct _EFI_DRIVER_BINDING_PROTOCOL {
EFI_DRIVER_BINDING_SUPPORTED Supported;
EFI_DRIVER_BINDING_START Start;

10
MdePkg/Include/Protocol/DriverConfiguration.h
View File

@ -146,13 +146,9 @@ EFI_STATUS
);
/**
Interface structure for the Driver Configuration Protocol.
@par Protocol Description:
Used to set configuration options for a controller that an EFI Driver is managing.
**/
///
/// Used to set configuration options for a controller that an EFI Driver is managing.
///
struct _EFI_DRIVER_CONFIGURATION_PROTOCOL {
EFI_DRIVER_CONFIGURATION_SET_OPTIONS SetOptions;
EFI_DRIVER_CONFIGURATION_OPTIONS_VALID OptionsValid;

9
MdePkg/Include/Protocol/DriverConfiguration2.h
View File

@ -155,12 +155,9 @@ EFI_STATUS
OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED *ActionRequired
);
/**
Interface structure for the Driver Configuration Protocol.
@par Protocol Description:
Used to set configuration options for a controller that an EFI Driver is managing.
**/
///
/// Used to set configuration options for a controller that an EFI Driver is managing.
///
struct _EFI_DRIVER_CONFIGURATION2_PROTOCOL {
EFI_DRIVER_CONFIGURATION2_SET_OPTIONS SetOptions;
EFI_DRIVER_CONFIGURATION2_OPTIONS_VALID OptionsValid;

9
MdePkg/Include/Protocol/DriverDiagnostics.h
View File

@ -97,12 +97,9 @@ EFI_STATUS
OUT CHAR16 **Buffer
);
/**
Interface structure for the Driver Diagnostics Protocol.
@par Protocol Description:
Used to perform diagnostics on a controller that an EFI Driver is managing.
**/
///
/// Used to perform diagnostics on a controller that an EFI Driver is managing.
///
struct _EFI_DRIVER_DIAGNOSTICS_PROTOCOL {
EFI_DRIVER_DIAGNOSTICS_RUN_DIAGNOSTICS RunDiagnostics;
///

9
MdePkg/Include/Protocol/DriverDiagnostics2.h
View File

@ -91,12 +91,9 @@ EFI_STATUS
OUT CHAR16 **Buffer
);
/**
Interface structure for the Driver Diagnostics2 Protocol.
@par Protocol Description:
Used to perform diagnostics on a controller that an EFI Driver is managing.
**/
///
/// Used to perform diagnostics on a controller that an EFI Driver is managing.
///
struct _EFI_DRIVER_DIAGNOSTICS2_PROTOCOL {
EFI_DRIVER_DIAGNOSTICS2_RUN_DIAGNOSTICS RunDiagnostics;
///

27
MdePkg/Include/Protocol/DriverFamilyOverride.h
View File

@ -46,22 +46,17 @@ UINT32
IN EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL *This
);
/**
@par Protocol Description:
When installed, the Driver Family Override Protocol produces a GUID that represets
a family of drivers. Drivers with the same GUID are members of the same family
When drivers are connected to controllers, drivers with a higher revision value
in the same driver family are connected with a higher priority than drivers
with a lower revision value in the same driver family. The EFI Boot Service
Connect Controller uses five rules to build a prioritied list of drivers when
a request is made to connect a driver to a controller. The Driver Family Protocol
rule is between the Platform Specific Driver Override Protocol and above the
Bus Specific Driver Override Protocol.
@param GetVersion
This function returns the version value associated with the driver specified by This.
**/
///
/// When installed, the Driver Family Override Protocol produces a GUID that represets
/// a family of drivers. Drivers with the same GUID are members of the same family
/// When drivers are connected to controllers, drivers with a higher revision value
/// in the same driver family are connected with a higher priority than drivers
/// with a lower revision value in the same driver family. The EFI Boot Service
/// Connect Controller uses five rules to build a prioritied list of drivers when
/// a request is made to connect a driver to a controller. The Driver Family Protocol
/// rule is between the Platform Specific Driver Override Protocol and above the
/// Bus Specific Driver Override Protocol.
///
struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL {
EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION GetVersion;
};

15
MdePkg/Include/Protocol/DriverSupportedEfiVersion.h
View File

@ -22,14 +22,13 @@
{ 0x5c198761, 0x16a8, 0x4e69, { 0x97, 0x2c, 0x89, 0xd6, 0x79, 0x54, 0xf8, 0x1d } }
/**
@par Protocol Description:
The EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL provides a
mechanism for an EFI driver to publish the version of the EFI
specification it conforms to. This protocol must be placed on
the drivers image handle when the driver's entry point is
called.
**/
///
/// The EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL provides a
/// mechanism for an EFI driver to publish the version of the EFI
/// specification it conforms to. This protocol must be placed on
/// the drivers image handle when the driver's entry point is
/// called.
///
typedef struct _EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL {
///
/// The size, in bytes, of the entire structure. Future versions of this

18
MdePkg/Include/Protocol/Ebc.h
View File

@ -133,18 +133,12 @@ EFI_STATUS
IN OUT UINT64 *Version
);
//
// Prototype for the actual EBC protocol interface
//
/**
This protocol provides the services that allow execution of EBC images.
@par Protocol Description:
The EFI EBC protocol provides services to load and execute EBC images, which will typically be
loaded into option ROMs. The image loader will load the EBC image, perform standard relocations,
and invoke the CreateThunk() service to create a thunk for the EBC image's entry point. The
image can then be run using the standard EFI start image services.
**/
///
/// The EFI EBC protocol provides services to load and execute EBC images, which will typically be
/// loaded into option ROMs. The image loader will load the EBC image, perform standard relocations,
/// and invoke the CreateThunk() service to create a thunk for the EBC image's entry point. The
/// image can then be run using the standard EFI start image services.
///
struct _EFI_EBC_PROTOCOL {
EFI_EBC_CREATE_THUNK CreateThunk;
EFI_EBC_UNLOAD_IMAGE UnloadImage;

13
MdePkg/Include/Protocol/EdidActive.h
View File

@ -22,13 +22,12 @@
0xbd8c1056, 0x9f36, 0x44ec, {0x92, 0xa8, 0xa6, 0x33, 0x7f, 0x81, 0x79, 0x86 } \
}
/**
@par Protocol Description:
This protocol contains the EDID information for an active video output device. This is either the
EDID information retrieved from the EFI_EDID_OVERRIDE_PROTOCOL if an override is
available, or an identical copy of the EDID information from the
EFI_EDID_DISCOVERED_PROTOCOL if no overrides are available.
**/
///
/// This protocol contains the EDID information for an active video output device. This is either the
/// EDID information retrieved from the EFI_EDID_OVERRIDE_PROTOCOL if an override is
/// available, or an identical copy of the EDID information from the
/// EFI_EDID_DISCOVERED_PROTOCOL if no overrides are available.
///
typedef struct {
///
/// The size, in bytes, of the Edid buffer. 0 if no EDID information

7
MdePkg/Include/Protocol/EdidDiscovered.h
View File

@ -23,10 +23,9 @@
0x1c0c34f6, 0xd380, 0x41fa, {0xa0, 0x49, 0x8a, 0xd0, 0x6c, 0x1a, 0x66, 0xaa } \
}
/**
@par Protocol Description:
This protocol contains the EDID information retrieved from a video output device.
**/
///
/// This protocol contains the EDID information retrieved from a video output device.
///
typedef struct {
///
/// The size, in bytes, of the Edid buffer. 0 if no EDID information

12
MdePkg/Include/Protocol/EdidOverride.h
View File

@ -54,15 +54,11 @@ EFI_STATUS
IN OUT UINT8 **Edid
);
/**
@par Protocol Description:
This protocol is produced by the platform to allow the platform to provide
EDID information to the producer of the Graphics Output protocol.
**/
///
/// This protocol is produced by the platform to allow the platform to provide
/// EDID information to the producer of the Graphics Output protocol.
///
struct _EFI_EDID_OVERRIDE_PROTOCOL {
///
/// Returns EDID values and attributes that the Video BIOS must use.
///
EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID GetEdid;
};

27
MdePkg/Include/Protocol/FirmwareVolume2.h
View File

@ -705,20 +705,19 @@ EFI_STATUS
);
/**
@par Protocol Description:
The Firmware Volume Protocol contains the file-level
abstraction to the firmware volume as well as some firmware
volume attribute reporting and configuration services. The
Firmware Volume Protocol is the interface used by all parts of
DXE that are not directly involved with managing the firmware
volume itself. This abstraction allows many varied types of
firmware volume implementations. A firmware volume may be a
flash device or it may be a file in the UEFI system partition,
for example. This level of firmware volume implementation
detail is not visible to the consumers of the Firmware Volume
Protocol.
**/
///
/// The Firmware Volume Protocol contains the file-level
/// abstraction to the firmware volume as well as some firmware
/// volume attribute reporting and configuration services. The
/// Firmware Volume Protocol is the interface used by all parts of
/// DXE that are not directly involved with managing the firmware
/// volume itself. This abstraction allows many varied types of
/// firmware volume implementations. A firmware volume may be a
/// flash device or it may be a file in the UEFI system partition,
/// for example. This level of firmware volume implementation
/// detail is not visible to the consumers of the Firmware Volume
/// Protocol.
///
struct _EFI_FIRMWARE_VOLUME2_PROTOCOL {
EFI_FV_GET_ATTRIBUTES GetVolumeAttributes;
EFI_FV_SET_ATTRIBUTES SetVolumeAttributes;

33
MdePkg/Include/Protocol/FirmwareVolumeBlock.h
View File

@ -328,30 +328,15 @@ EFI_STATUS
...
);
/**
@par Protocol Description:
The Firmware Volume Block Protocol is the low-level interface
to a firmware volume. File-level access to a firmware volume
should not be done using the Firmware Volume Block Protocol.
Normal access to a firmware volume must use the Firmware
Volume Protocol. Typically, only the file system driver that
produces the Firmware Volume Protocol will bind to the
Firmware Volume Block Protocol. The Firmware Volume Block
Protocol provides the following:
- Byte-level read/write functionality.
- Block-level erase functionality.
- It further exposes device-hardening features, such as may be
equired to protect the firmware from unwanted overwriting
and/or erasure.
- It is useful to layer a file system driver on top of the
Firmware Volume Block Protocol.
This file system driver produces the Firmware Volume Protocol,
which provides file-level access to a firmware volume. The
Firmware Volume Protocol abstracts the file system that is
used to format the firmware volume and the hardware
device-hardening features that may be present.
**/
///
/// The Firmware Volume Block Protocol is the low-level interface
/// to a firmware volume. File-level access to a firmware volume
/// should not be done using the Firmware Volume Block Protocol.
/// Normal access to a firmware volume must use the Firmware
/// Volume Protocol. Typically, only the file system driver that
/// produces the Firmware Volume Protocol will bind to the
/// Firmware Volume Block Protocol.
///
struct _EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL {
EFI_FVB_GET_ATTRIBUTES GetAttributes;
EFI_FVB_SET_ATTRIBUTES SetAttributes;

9
MdePkg/Include/Protocol/FormBrowser2.h
View File

@ -157,11 +157,10 @@ EFI_STATUS
IN CONST CHAR16 *VariableName OPTIONAL
);
/**
@par Protocol Description:
This interface will allow the caller to direct the configuration
driver to use either the HII database or use the passed-in packet of data.
**/
///
/// This interface will allow the caller to direct the configuration
/// driver to use either the HII database or use the passed-in packet of data.
///
struct _EFI_FORM_BROWSER2_PROTOCOL {
EFI_SEND_FORM2 SendForm;
EFI_BROWSER_CALLBACK2 BrowserCallback;

14
MdePkg/Include/Protocol/GraphicsOutput.h
View File

@ -190,16 +190,18 @@ typedef struct {
UINTN FrameBufferSize;
} EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE;
/**
@par Protocol Description:
Provides a basic abstraction to set video modes and copy pixels to and from
the graphics controller's frame buffer. The linear address of the hardware
frame buffer is also exposed so software can write directly to the video hardware.
**/
///
/// Provides a basic abstraction to set video modes and copy pixels to and from
/// the graphics controller's frame buffer. The linear address of the hardware
/// frame buffer is also exposed so software can write directly to the video hardware.
///
struct _EFI_GRAPHICS_OUTPUT_PROTOCOL {
EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE QueryMode;
EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE SetMode;
EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT Blt;
///
/// Pointer to EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE data.
///
EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *Mode;
};

15
MdePkg/Include/Protocol/GuidedSectionExtraction.h
View File

@ -126,14 +126,13 @@ EFI_STATUS
);
/**
@par Protocol Description:
Typically, protocol interface structures are identified by associating them with a GUID. Each
instance of a protocol with a given GUID must have the same interface structure. While all instances
of the GUIDed Section Extraction Protocol must have the same interface structure, they do not all
have the same GUID. The GUID that is associated with an instance of the GUIDed Section
Extraction Protocol is used to correlate it with the GUIDed section type that it is intended to process.
**/
///
/// Typically, protocol interface structures are identified by associating them with a GUID. Each
/// instance of a protocol with a given GUID must have the same interface structure. While all instances
/// of the GUIDed Section Extraction Protocol must have the same interface structure, they do not all
/// have the same GUID. The GUID that is associated with an instance of the GUIDed Section
/// Extraction Protocol is used to correlate it with the GUIDed section type that it is intended to process.
///
struct _EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL {
EFI_EXTRACT_GUIDED_SECTION ExtractSection;
};

9
MdePkg/Include/Protocol/Hash.h
View File

@ -128,11 +128,10 @@ EFI_STATUS
IN OUT EFI_HASH_OUTPUT *Hash
);
/**
@par Protocol Description:
This protocol allows creating a hash of an arbitrary message digest
using one or more hash algorithms.
**/
///
/// This protocol allows creating a hash of an arbitrary message digest
/// using one or more hash algorithms.
///
struct _EFI_HASH_PROTOCOL {
EFI_HASH_GET_HASH_SIZE GetHashSize;
EFI_HASH_HASH Hash;

11
MdePkg/Include/Protocol/HiiConfigAccess.h
View File

@ -199,12 +199,11 @@ EFI_STATUS
)
;
/**
@par Protocol Description:
This protocol provides a callable interface between the HII and
drivers. Only drivers which provide IFR data to HII are required
to publish this protocol.
**/
///
/// This protocol provides a callable interface between the HII and
/// drivers. Only drivers which provide IFR data to HII are required
/// to publish this protocol.
///
struct _EFI_HII_CONFIG_ACCESS_PROTOCOL {
EFI_HII_ACCESS_EXTRACT_CONFIG ExtractConfig;
EFI_HII_ACCESS_ROUTE_CONFIG RouteConfig;

11
MdePkg/Include/Protocol/HiiConfigRouting.h
View File

@ -390,12 +390,11 @@ EFI_STATUS
OUT EFI_STRING *AltCfgResp
);
/**
@par Protocol Description:
This protocol defines the configuration routing interfaces
between external applications and the HII. There may only be one
instance of this protocol in the system.
**/
///
/// This protocol defines the configuration routing interfaces
/// between external applications and the HII. There may only be one
/// instance of this protocol in the system.
///
struct _EFI_HII_CONFIG_ROUTING_PROTOCOL {
EFI_HII_ROUTING_EXTRACT_CONFIG ExtractConfig;
EFI_HII_ROUTING_EXPORT_CONFIG ExportConfig;

7
MdePkg/Include/Protocol/HiiDatabase.h
View File

@ -491,10 +491,9 @@ EFI_STATUS
OUT EFI_HANDLE *DriverHandle
);
/**
@par Protocol Description:
Database manager for HII-related data structures.
**/
///
/// Database manager for HII-related data structures.
///
struct _EFI_HII_DATABASE_PROTOCOL {
EFI_HII_DATABASE_NEW_PACK NewPackageList;
EFI_HII_DATABASE_REMOVE_PACK RemovePackageList;

7
MdePkg/Include/Protocol/HiiFont.h
View File

@ -479,10 +479,9 @@ EFI_STATUS
IN CONST EFI_STRING String OPTIONAL
);
/**
@par Protocol Description:
The protocol provides the service to retrieve the font informations.
**/
///
/// The protocol provides the service to retrieve the font informations.
///
struct _EFI_HII_FONT_PROTOCOL {
EFI_HII_STRING_TO_IMAGE StringToImage;
EFI_HII_STRING_ID_TO_IMAGE StringIdToImage;

7
MdePkg/Include/Protocol/HiiImage.h
View File

@ -336,10 +336,9 @@ IN UINTN BltY
);
/**
@par Protocol Description:
Services to access to images in the images database.
**/
///
/// Services to access to images in the images database.
///
struct _EFI_HII_IMAGE_PROTOCOL {
EFI_HII_NEW_IMAGE NewImage;
EFI_HII_GET_IMAGE GetImage;

7
MdePkg/Include/Protocol/HiiString.h
View File

@ -214,10 +214,9 @@ EFI_STATUS
);
/**
@par Protocol Description:
Services to manipulate the string.
**/
///
/// Services to manipulate the string.
///
struct _EFI_HII_STRING_PROTOCOL {
EFI_HII_NEW_STRING NewString;
EFI_HII_GET_STRING GetString;

7
MdePkg/Include/Protocol/IScsiInitiatorName.h
View File

@ -71,10 +71,9 @@ typedef EFI_STATUS
IN VOID *Buffer
);
/**
@par Protocol Description:
iSCSI Initiator Name Protocol for setting and obtaining the iSCSI Initiator Name.
**/
///
/// iSCSI Initiator Name Protocol for setting and obtaining the iSCSI Initiator Name.
///
struct _EFI_ISCSI_INITIATOR_NAME_PROTOCOL {
EFI_ISCSI_INITIATOR_NAME_GET Get;
EFI_ISCSI_INITIATOR_NAME_SET Set;

9
MdePkg/Include/Protocol/Ip4.h
View File

@ -394,11 +394,10 @@ EFI_STATUS
IN EFI_IP4_PROTOCOL *This
);
/**
@par Protocol Description:
The EFI IPv4 Protocol implements a simple packet-oriented interface that can be
used by drivers, daemons, and applications to transmit and receive network packets.
**/
///
/// The EFI IPv4 Protocol implements a simple packet-oriented interface that can be
/// used by drivers, daemons, and applications to transmit and receive network packets.
///
struct _EFI_IP4_PROTOCOL {
EFI_IP4_GET_MODE_DATA GetModeData;
EFI_IP4_CONFIGURE Configure;

9
MdePkg/Include/Protocol/Ip4Config.h
View File

@ -110,11 +110,10 @@ EFI_STATUS
OUT EFI_IP4_IPCONFIG_DATA *IpConfigData OPTIONAL
);
/**
@par Protocol Description:
The EFI_IP4_CONFIG_PROTOCOL driver performs platform- and policy-dependent
configuration for the EFI IPv4 Protocol driver.
**/
///
/// The EFI_IP4_CONFIG_PROTOCOL driver performs platform- and policy-dependent
/// configuration for the EFI IPv4 Protocol driver.
///
struct _EFI_IP4_CONFIG_PROTOCOL {
EFI_IP4_CONFIG_START Start;
EFI_IP4_CONFIG_STOP Stop;

7
MdePkg/Include/Protocol/LoadFile.h
View File

@ -76,10 +76,9 @@ EFI_STATUS
IN VOID *Buffer OPTIONAL
);
/**
@par Protocol Description:
The EFI_LOAD_FILE_PROTOCOL is a simple protocol used to obtain files from arbitrary devices.
**/
///
/// The EFI_LOAD_FILE_PROTOCOL is a simple protocol used to obtain files from arbitrary devices.
///
struct _EFI_LOAD_FILE_PROTOCOL {
EFI_LOAD_FILE LoadFile;
};

22
MdePkg/Include/Protocol/LoadedImage.h
View File

@ -45,10 +45,9 @@
///
#define EFI_LOADED_IMAGE_INFORMATION_REVISION EFI_LOADED_IMAGE_PROTOCOL_REVISION
/**
@par Protocol Description:
Can be used on any image handle to obtain information about the loaded image.
**/
///
/// Can be used on any image handle to obtain information about the loaded image.
///
typedef struct {
///
/// Defines the revision of the EFI_LOADED_IMAGE_PROTOCOL structure.
@ -61,6 +60,10 @@ typedef struct {
/// the firmware's boot manager.
///
EFI_HANDLE ParentHandle;
///
/// the image's EFI system table pointer.
///
EFI_SYSTEM_TABLE *SystemTable;
//
@ -103,12 +106,17 @@ typedef struct {
/// The size in bytes of the loaded image.
///
UINT64 ImageSize;
///
/// The memory type that the code sections were loaded as.
///
EFI_MEMORY_TYPE ImageCodeType;
///
/// The memory type that the data sections were loaded as.
///
EFI_MEMORY_TYPE ImageDataType;
//
// If the driver image supports a dynamic unload request
//
EFI_IMAGE_UNLOAD Unload;
} EFI_LOADED_IMAGE_PROTOCOL;

9
MdePkg/Include/Protocol/ManagedNetwork.h
View File

@ -289,11 +289,10 @@ EFI_STATUS
IN EFI_MANAGED_NETWORK_PROTOCOL *This
);
/**
@par Protocol Description:
The MNP is used by network applications (and drivers) to
perform raw (unformatted) asynchronous network packet I/O.
**/
///
/// The MNP is used by network applications (and drivers) to
/// perform raw (unformatted) asynchronous network packet I/O.
///
struct _EFI_MANAGED_NETWORK_PROTOCOL {
EFI_MANAGED_NETWORK_GET_MODE_DATA GetModeData;
EFI_MANAGED_NETWORK_CONFIGURE Configure;

20
MdePkg/Include/Protocol/Metronome.h
View File

@ -57,21 +57,11 @@ EFI_STATUS
IN UINT32 TickNumber
);
/**
Interface stucture for the Metronome Architectural Protocol.
@par Protocol Description:
This protocol provides access to a known time source in the platform to the
core. The core uses this known time source to produce core services that
require calibrated delays.
@param WaitForTick
Waits for a specified number of ticks from a known time source
in the platform. The actual time passed between entry of this
function and the first tick is between 0 and TickPeriod 100 nS
units. If you want to guarantee that at least TickPeriod time
has elapsed, wait for two ticks.
**/
///
/// This protocol provides access to a known time source in the platform to the
/// core. The core uses this known time source to produce core services that
/// require calibrated delays.
///
struct _EFI_METRONOME_ARCH_PROTOCOL {
EFI_METRONOME_WAIT_FOR_TICK WaitForTick;

14
MdePkg/Include/Protocol/Mtftp4.h
View File

@ -460,15 +460,11 @@ EFI_STATUS
IN EFI_MTFTP4_PROTOCOL *This
);
/**
The EFI MTFTPv4 Protocol provides basic services for client-side unicast
and/or multicast TFTP operations.
@par Protocol Description:
The EFI_MTFTP4_PROTOCOL is designed to be used by UEFI drivers and applications
to transmit and receive data files. The EFI MTFTPv4 Protocol driver uses
the underlying EFI UDPv4 Protocol driver and EFI IPv4 Protocol driver.
**/
///
/// The EFI_MTFTP4_PROTOCOL is designed to be used by UEFI drivers and applications
/// to transmit and receive data files. The EFI MTFTPv4 Protocol driver uses
/// the underlying EFI UDPv4 Protocol driver and EFI IPv4 Protocol driver.
///
struct _EFI_MTFTP4_PROTOCOL {
EFI_MTFTP4_GET_MODE_DATA GetModeData;
EFI_MTFTP4_CONFIGURE Configure;

9
MdePkg/Include/Protocol/NetworkInterfaceIdentifier.h
View File

@ -43,11 +43,10 @@ typedef enum {
EfiNetworkInterfaceUndi = 1
} EFI_NETWORK_PROTOCOL_TYPE;
/**
@par Protocol Description:
An optional protocol that is used to describe details about the software
layer that is used to produce the Simple Network Protocol.
**/
///
/// An optional protocol that is used to describe details about the software
/// layer that is used to produce the Simple Network Protocol.
///
struct _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL {
///
/// The revision of the EFI_NETWORK_INTERFACE_IDENTIFIER protocol.

10
MdePkg/Include/Protocol/Pcd.h
View File

@ -813,13 +813,9 @@ EFI_STATUS
IN OUT CONST EFI_GUID **Guid
);
//
// Interface structure for the PCD Protocol
//
/**
@par Protocol Description:
This service abstracts the ability to set/get Platform Configuration Database (PCD).
**/
///
/// This service abstracts the ability to set/get Platform Configuration Database (PCD).
///
typedef struct {
PCD_PROTOCOL_SET_SKU SetSku;

15
MdePkg/Include/Protocol/PciIo.h
View File

@ -474,14 +474,13 @@ EFI_STATUS
IN OUT UINT64 *Length
);
/**
@par Protocol Description:
The EFI_PCI_IO_PROTOCOL provides the basic Memory, I/O, PCI configuration,
and DMA interfaces that are used to abstract accesses to PCI controllers.
There is one EFI_PCI_IO_PROTOCOL instance for each PCI controller on a PCI bus.
A device driver that wishes to manage a PCI controller in a system will have to
retrieve the EFI_PCI_IO_PROTOCOL instance that is associated with the PCI controller.
**/
///
/// The EFI_PCI_IO_PROTOCOL provides the basic Memory, I/O, PCI configuration,
/// and DMA interfaces that are used to abstract accesses to PCI controllers.
/// There is one EFI_PCI_IO_PROTOCOL instance for each PCI controller on a PCI bus.
/// A device driver that wishes to manage a PCI controller in a system will have to
/// retrieve the EFI_PCI_IO_PROTOCOL instance that is associated with the PCI controller.
///
struct _EFI_PCI_IO_PROTOCOL {
EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollMem;
EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollIo;

9
MdePkg/Include/Protocol/PciRootBridgeIo.h
View File

@ -358,11 +358,10 @@ EFI_STATUS
OUT VOID **Resources
);
/**
@par Protocol Description:
Provides the basic Memory, I/O, PCI configuration, and DMA interfaces that are
used to abstract accesses to PCI controllers behind a PCI Root Bridge Controller.
**/
///
/// Provides the basic Memory, I/O, PCI configuration, and DMA interfaces that are
/// used to abstract accesses to PCI controllers behind a PCI Root Bridge Controller.
///
struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL {
///
/// The EFI_HANDLE of the PCI Host Bridge of which this PCI Root Bridge is a member.

24
MdePkg/Include/Protocol/PlatformDriverOverride.h
View File

@ -119,20 +119,16 @@ EFI_STATUS
IN EFI_HANDLE DriverImageHandle
);
//
// Interface structure for the Platform Driver Override Protocol
//
/**
@par Protocol Description:
This protocol matches one or more drivers to a controller. A platform driver
produces this protocol, and it is installed on a separate handle. This protocol
is used by the ConnectController() boot service to select the best driver
for a controller. All of the drivers returned by this protocol have a higher
precedence than drivers found from an EFI Bus Specific Driver Override Protocol
or drivers found from the general UEFI driver Binding search algorithm. If more
than one driver is returned by this protocol, then the drivers are returned in
order from highest precedence to lowest precedence.
**/
///
/// This protocol matches one or more drivers to a controller. A platform driver
/// produces this protocol, and it is installed on a separate handle. This protocol
/// is used by the ConnectController() boot service to select the best driver
/// for a controller. All of the drivers returned by this protocol have a higher
/// precedence than drivers found from an EFI Bus Specific Driver Override Protocol
/// or drivers found from the general UEFI driver Binding search algorithm. If more
/// than one driver is returned by this protocol, then the drivers are returned in
/// order from highest precedence to lowest precedence.
///
struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL {
EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER GetDriver;
EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH GetDriverPath;

35
MdePkg/Include/Protocol/PlatformToDriverConfiguration.h
View File

@ -253,29 +253,18 @@ EFI_STATUS
);
/**
@par Protocol Description:
The EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL is used by the
UEFI driver to query the platform for configuration information.
The UEFI driver calls Query() multiple times to get
configuration information from the platform. For every call to
Query() there must be a matching call to Response() so the
UEFI driver can inform the platform how it used the
information passed in from Query(). It's legal for a UEFI
driver to use Response() to inform the platform it does not
understand the data returned via Query() and thus no action was
taken.
@param Query Called by the UEFI Driver Start() function to
get configuration information from the
platform.
@param Response Called by the UEFI Driver Start() function
to let the platform know how UEFI driver
processed the data return from Query.
**/
///
/// The EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL is used by the
/// UEFI driver to query the platform for configuration information.
/// The UEFI driver calls Query() multiple times to get
/// configuration information from the platform. For every call to
/// Query() there must be a matching call to Response() so the
/// UEFI driver can inform the platform how it used the
/// information passed in from Query(). It's legal for a UEFI
/// driver to use Response() to inform the platform it does not
/// understand the data returned via Query() and thus no action was
/// taken.
///
struct _EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL {
EFI_PLATFORM_TO_DRIVER_CONFIGURATION_QUERY Query;
EFI_PLATFORM_TO_DRIVER_CONFIGURATION_RESPONSE Response;

20
MdePkg/Include/Protocol/PxeBaseCode.h
View File

@ -608,15 +608,14 @@ EFI_STATUS
//
#define EFI_PXE_BASE_CODE_INTERFACE_REVISION EFI_PXE_BASE_CODE_PROTOCOL_REVISION
/**
@par Protocol Description:
The EFI_PXE_BASE_CODE_PROTOCOL is used to control PXE-compatible devices.
An EFI_PXE_BASE_CODE_PROTOCOL will be layered on top of an
EFI_MANAGED_NETWORK_PROTOCOL protocol in order to perform packet level transactions.
The EFI_PXE_BASE_CODE_PROTOCOL handle also supports the
EFI_LOAD_FILE_PROTOCOL protocol. This provides a clean way to obtain control from the
boot manager if the boot path is from the remote device.
**/
///
/// The EFI_PXE_BASE_CODE_PROTOCOL is used to control PXE-compatible devices.
/// An EFI_PXE_BASE_CODE_PROTOCOL will be layered on top of an
/// EFI_MANAGED_NETWORK_PROTOCOL protocol in order to perform packet level transactions.
/// The EFI_PXE_BASE_CODE_PROTOCOL handle also supports the
/// EFI_LOAD_FILE_PROTOCOL protocol. This provides a clean way to obtain control from the
/// boot manager if the boot path is from the remote device.
///
struct _EFI_PXE_BASE_CODE_PROTOCOL {
///
/// The revision of the EFI_PXE_BASE_CODE_PROTOCOL. All future revisions must
@ -636,6 +635,9 @@ struct _EFI_PXE_BASE_CODE_PROTOCOL {
EFI_PXE_BASE_CODE_SET_PARAMETERS SetParameters;
EFI_PXE_BASE_CODE_SET_STATION_IP SetStationIp;
EFI_PXE_BASE_CODE_SET_PACKETS SetPackets;
///
/// Pointer to the EFI_PXE_BASE_CODE_MODE data for this device.
///
EFI_PXE_BASE_CODE_MODE *Mode;
};

10
MdePkg/Include/Protocol/PxeBaseCodeCallBack.h
View File

@ -88,12 +88,10 @@ EFI_PXE_BASE_CODE_CALLBACK_STATUS
IN EFI_PXE_BASE_CODE_PACKET *Packet OPTIONAL
);
/**
@par Protocol Description:
Protocol that is invoked when the PXE Base Code Protocol is about
to transmit, has received, or is waiting to receive a packet.
**/
///
/// Protocol that is invoked when the PXE Base Code Protocol is about
/// to transmit, has received, or is waiting to receive a packet.
///
struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL {
///
/// The revision of the EFI_PXE_BASE_CODE_PROTOCOL. All future revisions must

24
MdePkg/Include/Protocol/Runtime.h
View File

@ -61,20 +61,16 @@ struct _EFI_RUNTIME_EVENT_ENTRY {
EFI_LIST_ENTRY Link;
};
//
// Interface stucture for the Runtime Architectural Protocol
//
/**
@par Protocol Description:
Allows the runtime functionality of the DXE Foundation to be contained in a
separate driver. It also provides hooks for the DXE Foundation to export
information that is needed at runtime. As such, this protocol allows the DXE
Foundation to manage runtime drivers and events. This protocol also implies
that the runtime services required to transition to virtual mode,
SetVirtualAddressMap() and ConvertPointer(), have been registered into the
EFI Runtime Table in the EFI System Partition. This protocol must be produced
by a runtime DXE driver and may only be consumed by the DXE Foundation.
**/
///
/// Allows the runtime functionality of the DXE Foundation to be contained in a
/// separate driver. It also provides hooks for the DXE Foundation to export
/// information that is needed at runtime. As such, this protocol allows the DXE
/// Foundation to manage runtime drivers and events. This protocol also implies
/// that the runtime services required to transition to virtual mode,
/// SetVirtualAddressMap() and ConvertPointer(), have been registered into the
/// EFI Runtime Table in the EFI System Partition. This protocol must be produced
/// by a runtime DXE driver and may only be consumed by the DXE Foundation.
///
struct _EFI_RUNTIME_ARCH_PROTOCOL {
///
/// A list of type EFI_RUNTIME_IMAGE_ENTRY.

7
MdePkg/Include/Protocol/ScsiIo.h
View File

@ -215,10 +215,9 @@ EFI_STATUS
IN EFI_EVENT Event OPTIONAL
);
/**
@par Protocol Description:
Provides services to manage and communicate with SCSI devices.
**/
///
/// Provides services to manage and communicate with SCSI devices.
///
struct _EFI_SCSI_IO_PROTOCOL {
EFI_SCSI_IO_PROTOCOL_GET_DEVICE_TYPE GetDeviceType;
EFI_SCSI_IO_PROTOCOL_GET_DEVICE_LOCATION GetDeviceLocation;

18
MdePkg/Include/Protocol/ScsiPassThru.h
View File

@ -296,15 +296,17 @@ EFI_STATUS
IN UINT64 Lun
);
/**
@par Protocol Description:
The EFI_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel and
the ability to send SCI Request Packets to any SCSI device attached to that SCSI channel. The
information includes the Target ID of the host controller on the SCSI channel, the attributes of
the SCSI channel, the printable name for the SCSI controller, and the printable name of the
SCSI channel.
**/
///
/// The EFI_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel and
/// the ability to send SCI Request Packets to any SCSI device attached to that SCSI channel. The
/// information includes the Target ID of the host controller on the SCSI channel, the attributes of
/// the SCSI channel, the printable name for the SCSI controller, and the printable name of the
/// SCSI channel.
///
struct _EFI_SCSI_PASS_THRU_PROTOCOL {
///
/// A pointer to the EFI_SCSI_PASS_THRU_MODE data for this SCSI channel.
///
EFI_SCSI_PASS_THRU_MODE *Mode;
EFI_SCSI_PASS_THRU_PASSTHRU PassThru;
EFI_SCSI_PASS_THRU_GET_NEXT_DEVICE GetNextDevice;

16
MdePkg/Include/Protocol/ScsiPassThruExt.h
View File

@ -308,14 +308,16 @@ EFI_STATUS
IN OUT UINT8 **Target
);
/**
@par Protocol Description:
The EFI_EXT_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel
and the ability to send SCI Request Packets to any SCSI device attached to
that SCSI channel. The information includes the Target ID of the host controller
on the SCSI channel and the attributes of the SCSI channel.
**/
///
/// The EFI_EXT_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel
/// and the ability to send SCI Request Packets to any SCSI device attached to
/// that SCSI channel. The information includes the Target ID of the host controller
/// on the SCSI channel and the attributes of the SCSI channel.
///
struct _EFI_EXT_SCSI_PASS_THRU_PROTOCOL {
///
/// A pointer to the EFI_EXT_SCSI_PASS_THRU_MODE data for this SCSI channel.
///
EFI_EXT_SCSI_PASS_THRU_MODE *Mode;
EFI_EXT_SCSI_PASS_THRU_PASSTHRU PassThru;
EFI_EXT_SCSI_PASS_THRU_GET_NEXT_TARGET_LUN GetNextTargetLun;

27
MdePkg/Include/Protocol/Security.h
View File

@ -89,28 +89,11 @@ EFI_STATUS
IN EFI_DEVICE_PATH_PROTOCOL *File
);
//
// Interface stucture for the Timer Architectural Protocol
//
/**
@par Protocol Description:
The EFI_SECURITY_ARCH_PROTOCOL is used to abstract platform-specific policy
from the DXE core. This includes locking flash upon failure to authenticate,
attestation logging, and other exception operations.
The driver that produces the EFI_SECURITY_ARCH_PROTOCOL may also optionally
install the EFI_SECURITY_POLICY_PROTOCOL_GUID onto a new handle with a NULL
interface. The existence of this GUID in the protocol database means that
the GUIDed Section Extraction Protocol should authenticate the contents of
an Authentication Section. The expectation is that the GUIDed Section
Extraction protocol will look for the existence of the EFI_SECURITY_POLICY_
PROTOCOL_GUID in the protocol database. If it exists, then the publication
thereof is taken as an injunction to attempt an authentication of any section
wrapped in an Authentication Section. See the Firmware File System
Specification for details on the GUIDed Section Extraction Protocol and
Authentication Sections.
**/
///
/// The EFI_SECURITY_ARCH_PROTOCOL is used to abstract platform-specific policy
/// from the DXE core. This includes locking flash upon failure to authenticate,
/// attestation logging, and other exception operations.
///
struct _EFI_SECURITY_ARCH_PROTOCOL {
EFI_SECURITY_FILE_AUTHENTICATION_STATE FileAuthenticationState;
};

15
MdePkg/Include/Protocol/SerialIo.h
View File

@ -266,12 +266,11 @@ typedef struct {
#define EFI_SERIAL_IO_PROTOCOL_REVISION 0x00010000
#define SERIAL_IO_INTERFACE_REVISION EFI_SERIAL_IO_PROTOCOL_REVISION
/**
@par Protocol Description:
The Serial I/O protocol is used to communicate with UART-style serial devices.
These can be standard UART serial ports in PC-AT systems, serial ports attached
to a USB interface, or potentially any character-based I/O device.
**/
///
/// The Serial I/O protocol is used to communicate with UART-style serial devices.
/// These can be standard UART serial ports in PC-AT systems, serial ports attached
/// to a USB interface, or potentially any character-based I/O device.
///
struct _EFI_SERIAL_IO_PROTOCOL {
///
/// The revision to which the EFI_SERIAL_IO_PROTOCOL adheres. All future revisions
@ -285,7 +284,9 @@ struct _EFI_SERIAL_IO_PROTOCOL {
EFI_SERIAL_GET_CONTROL_BITS GetControl;
EFI_SERIAL_WRITE Write;
EFI_SERIAL_READ Read;
///
/// Pointer to SERIAL_IO_MODE data.
///
EFI_SERIAL_IO_MODE *Mode;
};

23
MdePkg/Include/Protocol/ServiceBinding.h
View File

@ -67,18 +67,17 @@ EFI_STATUS
IN EFI_HANDLE ChildHandle
);
/**
@par Protocol Description:
The EFI_SERVICE_BINDING_PROTOCOL provides member functions to create and destroy
child handles. A driver is responsible for adding protocols to the child handle
in CreateChild() and removing protocols in DestroyChild(). It is also required
that the CreateChild() function opens the parent protocol BY_CHILD_CONTROLLER
to establish the parent-child relationship, and closes the protocol in DestroyChild().
The pseudo code for CreateChild() and DestroyChild() is provided to specify the
required behavior, not to specify the required implementation. Each consumer of
a software protocol is responsible for calling CreateChild() when it requires the
protocol and calling DestroyChild() when it is finished with that protocol.
**/
///
/// The EFI_SERVICE_BINDING_PROTOCOL provides member functions to create and destroy
/// child handles. A driver is responsible for adding protocols to the child handle
/// in CreateChild() and removing protocols in DestroyChild(). It is also required
/// that the CreateChild() function opens the parent protocol BY_CHILD_CONTROLLER
/// to establish the parent-child relationship, and closes the protocol in DestroyChild().
/// The pseudo code for CreateChild() and DestroyChild() is provided to specify the
/// required behavior, not to specify the required implementation. Each consumer of
/// a software protocol is responsible for calling CreateChild() when it requires the
/// protocol and calling DestroyChild() when it is finished with that protocol.
///
struct _EFI_SERVICE_BINDING_PROTOCOL {
EFI_SERVICE_BINDING_CREATE_CHILD CreateChild;
EFI_SERVICE_BINDING_DESTROY_CHILD DestroyChild;

15
MdePkg/Include/Protocol/SimpleFileSystem.h
View File

@ -314,14 +314,13 @@ EFI_STATUS
//
#define EFI_FILE_REVISION EFI_FILE_PROTOCOL_REVISION
/**
@par Protocol Description:
The EFI_FILE_PROTOCOL provides file IO access to supported file systems.
An EFI_FILE_PROTOCOL provides access to a file's or directory's contents,
and is also a reference to a location in the directory tree of the file system
in which the file resides. With any given file handle, other files may be opened
relative to this file's location, yielding new file handles.
**/
///
/// The EFI_FILE_PROTOCOL provides file IO access to supported file systems.
/// An EFI_FILE_PROTOCOL provides access to a file's or directory's contents,
/// and is also a reference to a location in the directory tree of the file system
/// in which the file resides. With any given file handle, other files may be opened
/// relative to this file's location, yielding new file handles.
///
struct _EFI_FILE_PROTOCOL {
///
/// The version of the EFI_FILE_PROTOCOL interface. The version specified

16
MdePkg/Include/Protocol/SimpleNetwork.h
View File

@ -552,13 +552,12 @@ EFI_STATUS
//
#define EFI_SIMPLE_NETWORK_INTERFACE_REVISION EFI_SIMPLE_NETWORK_PROTOCOL_REVISION
/**
@par Protocol Description:
The EFI_SIMPLE_NETWORK_PROTOCOL protocol is used to initialize access
to a network adapter. Once the network adapter initializes,
the EFI_SIMPLE_NETWORK_PROTOCOL protocol provides services that
allow packets to be transmitted and received.
**/
///
/// The EFI_SIMPLE_NETWORK_PROTOCOL protocol is used to initialize access
/// to a network adapter. Once the network adapter initializes,
/// the EFI_SIMPLE_NETWORK_PROTOCOL protocol provides services that
/// allow packets to be transmitted and received.
///
struct _EFI_SIMPLE_NETWORK_PROTOCOL {
///
/// Revision of the EFI_SIMPLE_NETWORK_PROTOCOL. All future revisions must
@ -583,6 +582,9 @@ struct _EFI_SIMPLE_NETWORK_PROTOCOL {
/// Event used with WaitForEvent() to wait for a packet to be received.
///
EFI_EVENT WaitForPacket;
///
/// Pointer to the EFI_SIMPLE_NETWORK_MODE data for the device.
///
EFI_SIMPLE_NETWORK_MODE *Mode;
};

18
MdePkg/Include/Protocol/SimplePointer.h
View File

@ -83,14 +83,13 @@ EFI_STATUS
IN OUT EFI_SIMPLE_POINTER_STATE *State
);
/**
@par Protocol Description:
The EFI_SIMPLE_POINTER_PROTOCOL provides a set of services for a pointer
device that can use used as an input device from an application written
to this specification. The services include the ability to reset the
pointer device, retrieve get the state of the pointer device, and
retrieve the capabilities of the pointer device.
**/
///
/// The EFI_SIMPLE_POINTER_PROTOCOL provides a set of services for a pointer
/// device that can use used as an input device from an application written
/// to this specification. The services include the ability to reset the
/// pointer device, retrieve get the state of the pointer device, and
/// retrieve the capabilities of the pointer device.
///
struct _EFI_SIMPLE_POINTER_PROTOCOL {
EFI_SIMPLE_POINTER_RESET Reset;
EFI_SIMPLE_POINTER_GET_STATE GetState;
@ -98,6 +97,9 @@ struct _EFI_SIMPLE_POINTER_PROTOCOL {
/// Event to use with WaitForEvent() to wait for input from the pointer device.
///
EFI_EVENT WaitForInput;
///
/// Pointer to EFI_SIMPLE_POINTER_MODE data.
///
EFI_SIMPLE_POINTER_MODE *Mode;
};

9
MdePkg/Include/Protocol/SimpleTextIn.h
View File

@ -118,11 +118,10 @@ EFI_STATUS
OUT EFI_INPUT_KEY *Key
);
/**
@par Protocol Description:
The EFI_SIMPLE_TEXT_INPUT_PROTOCOL is used on the ConsoleIn device.
It is the minimum required protocol for ConsoleIn.
**/
///
/// The EFI_SIMPLE_TEXT_INPUT_PROTOCOL is used on the ConsoleIn device.
/// It is the minimum required protocol for ConsoleIn.
///
struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL {
EFI_INPUT_RESET Reset;
EFI_INPUT_READ_KEY ReadKeyStroke;

12
MdePkg/Include/Protocol/SimpleTextInEx.h
View File

@ -300,12 +300,12 @@ EFI_STATUS
);
/**
The EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL is used on the ConsoleIn
device. It is an extension to the Simple Text Input protocol
which allows a variety of extended shift state information to be
returned.
**/
///
/// The EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL is used on the ConsoleIn
/// device. It is an extension to the Simple Text Input protocol
/// which allows a variety of extended shift state information to be
/// returned.
///
struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL{
EFI_INPUT_RESET_EX Reset;
EFI_INPUT_READ_KEY_EX ReadKeyStrokeEx;

19
MdePkg/Include/Protocol/SimpleTextOut.h
View File

@ -373,13 +373,12 @@ typedef struct {
BOOLEAN CursorVisible;
} EFI_SIMPLE_TEXT_OUTPUT_MODE;
/**
@par Protocol Description:
The SIMPLE_TEXT_OUTPUT protocol is used to control text-based output devices.
It is the minimum required protocol for any handle supplied as the ConsoleOut
or StandardError device. In addition, the minimum supported text mode of such
devices is at least 80 x 25 characters.
**/
///
/// The SIMPLE_TEXT_OUTPUT protocol is used to control text-based output devices.
/// It is the minimum required protocol for any handle supplied as the ConsoleOut
/// or StandardError device. In addition, the minimum supported text mode of such
/// devices is at least 80 x 25 characters.
///
struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL {
EFI_TEXT_RESET Reset;
@ -394,9 +393,9 @@ struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL {
EFI_TEXT_SET_CURSOR_POSITION SetCursorPosition;
EFI_TEXT_ENABLE_CURSOR EnableCursor;
//
// Current mode
//
///
/// Pointer to SIMPLE_TEXT_OUTPUT_MODE data.
///
EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
};

11
MdePkg/Include/Protocol/SmbusHc.h
View File

@ -274,12 +274,11 @@ EFI_STATUS
);
/**
@par Protocol Description:
The EFI_SMBUS_HC_PROTOCOL provides SMBus host controller management and basic data
transactions over SMBus. There is one EFI_SMBUS_HC_PROTOCOL instance for each SMBus
host controller.
**/
///
/// The EFI_SMBUS_HC_PROTOCOL provides SMBus host controller management and basic data
/// transactions over SMBus. There is one EFI_SMBUS_HC_PROTOCOL instance for each SMBus
/// host controller.
///
struct _EFI_SMBUS_HC_PROTOCOL {
EFI_SMBUS_HC_EXECUTE_OPERATION Execute;
EFI_SMBUS_HC_PROTOCOL_ARP_DEVICE ArpDevice;

12
MdePkg/Include/Protocol/StatusCode.h
View File

@ -56,13 +56,11 @@ EFI_STATUS
IN EFI_STATUS_CODE_DATA *Data OPTIONAL
);
/**
@par Protocol Description:
Provides the service required to report a status code to the platform firmware.
This protocol must be produced by a runtime DXE driver and may be consumed
only by the DXE Foundation.
**/
///
/// Provides the service required to report a status code to the platform firmware.
/// This protocol must be produced by a runtime DXE driver and may be consumed
/// only by the DXE Foundation.
///
typedef struct _EFI_STATUS_CODE_PROTOCOL {
EFI_REPORT_STATUS_CODE ReportStatusCode;
} EFI_STATUS_CODE_PROTOCOL;

14
MdePkg/Include/Protocol/TapeIo.h
View File

@ -217,14 +217,12 @@ EFI_STATUS
IN BOOLEAN ExtendedVerification
);
/**
@par Protocol Description:
The EFI_TAPE_IO_PROTOCOL provides basic sequential operations for tape devices.
These include read, write, rewind, space, write filemarks and reset functions.
Per this specification, a boot application uses the services of this protocol
to load the bootloader image from tape.
**/
///
/// The EFI_TAPE_IO_PROTOCOL provides basic sequential operations for tape devices.
/// These include read, write, rewind, space, write filemarks and reset functions.
/// Per this specification, a boot application uses the services of this protocol
/// to load the bootloader image from tape.
///
struct _EFI_TAPE_IO_PROTOCOL {
EFI_TAPE_READ TapeRead;
EFI_TAPE_WRITE TapeWrite;

8
MdePkg/Include/Protocol/TcgService.h
View File

@ -197,11 +197,9 @@ EFI_STATUS
OUT EFI_PHYSICAL_ADDRESS *EventLogLastEntry
);
/**
@par Protocol Description:
The EFI_TCG Protocol abstracts TCG activity.
**/
///
/// The EFI_TCG Protocol abstracts TCG activity.
///
struct _EFI_TCG_PROTOCOL {
EFI_TCG_STATUS_CHECK StatusCheck;
EFI_TCG_HASH_ALL HashAll;

15
MdePkg/Include/Protocol/Tcp4.h
View File

@ -475,14 +475,13 @@ EFI_STATUS
IN EFI_TCP4_PROTOCOL *This
);
/**
@par Protocol Description:
The EFI_TCP4_PROTOCOL defines the EFI TCPv4 Protocol child to be used by
any network drivers or applications to send or receive data stream.
It can either listen on a specified port as a service or actively connected
to remote peer as a client. Each instance has its own independent settings,
such as the routing table.
**/
///
/// The EFI_TCP4_PROTOCOL defines the EFI TCPv4 Protocol child to be used by
/// any network drivers or applications to send or receive data stream.
/// It can either listen on a specified port as a service or actively connected
/// to remote peer as a client. Each instance has its own independent settings,
/// such as the routing table.
///
struct _EFI_TCP4_PROTOCOL {
EFI_TCP4_GET_MODE_DATA GetModeData;
EFI_TCP4_CONFIGURE Configure;

19
MdePkg/Include/Protocol/Timer.h
View File

@ -160,17 +160,14 @@ EFI_STATUS
);
/**
Interface stucture for the Timer Architectural Protocol.
@par Protocol Description:
This protocol provides the services to initialize a periodic timer
interrupt, and to register a handler that is called each time the timer
interrupt fires. It may also provide a service to adjust the rate of the
periodic timer interrupt. When a timer interrupt occurs, the handler is
passed the amount of time that has passed since the previous timer
interrupt.
**/
///
/// This protocol provides the services to initialize a periodic timer
/// interrupt, and to register a handler that is called each time the timer
/// interrupt fires. It may also provide a service to adjust the rate of the
/// periodic timer interrupt. When a timer interrupt occurs, the handler is
/// passed the amount of time that has passed since the previous timer
/// interrupt.
///
struct _EFI_TIMER_ARCH_PROTOCOL {
EFI_TIMER_REGISTER_HANDLER RegisterHandler;
EFI_TIMER_SET_TIMER_PERIOD SetTimerPeriod;

15
MdePkg/Include/Protocol/Udp4.h
View File

@ -342,14 +342,13 @@ EFI_STATUS
IN EFI_UDP4_COMPLETION_TOKEN *Token OPTIONAL
);
/**
@par Protocol Description:
The EFI_UDP4_PROTOCOL defines an EFI UDPv4 Protocol session that can be used
by any network drivers, applications, or daemons to transmit or receive UDP packets.
This protocol instance can either be bound to a specified port as a service or
connected to some remote peer as an active client. Each instance has its own settings,
such as the routing table and group table, which are independent from each other.
**/
///
/// The EFI_UDP4_PROTOCOL defines an EFI UDPv4 Protocol session that can be used
/// by any network drivers, applications, or daemons to transmit or receive UDP packets.
/// This protocol instance can either be bound to a specified port as a service or
/// connected to some remote peer as an active client. Each instance has its own settings,
/// such as the routing table and group table, which are independent from each other.
///
struct _EFI_UDP4_PROTOCOL {
EFI_UDP4_GET_MODE_DATA GetModeData;
EFI_UDP4_CONFIGURE Configure;

14
MdePkg/Include/Protocol/UgaDraw.h
View File

@ -151,16 +151,10 @@ EFI_STATUS
IN UINTN Delta OPTIONAL
);
/**
This protocol provides a basic abstraction to set video modes and
copy pixels to and from the graphics controller's frame buffer.
@par Protocol Description:
The EFI_UGA_DRAW_PROTOCOL provides a software abstraction to allow pixels to be drawn
directly to the frame buffer. The EFI_UGA_DRAW_PROTOCOL is designed to be lightweight and
to support the basic needs of graphics output prior to Operating System boot.
**/
///
/// This protocol provides a basic abstraction to set video modes and
/// copy pixels to and from the graphics controller's frame buffer.
///
struct _EFI_UGA_DRAW_PROTOCOL {
EFI_UGA_DRAW_PROTOCOL_GET_MODE GetMode;
EFI_UGA_DRAW_PROTOCOL_SET_MODE SetMode;

7
MdePkg/Include/Protocol/UgaIo.h
View File

@ -162,10 +162,9 @@ typedef UGA_STATUS
IN OUT PUGA_IO_REQUEST pIoRequest
);
/**
@par Protocol Description:
Provides a basic abstraction to send I/O requests to the graphics device and any of its children.
**/
///
/// Provides a basic abstraction to send I/O requests to the graphics device and any of its children.
///
struct _EFI_UGA_IO_PROTOCOL {
EFI_UGA_IO_PROTOCOL_CREATE_DEVICE CreateDevice;
EFI_UGA_IO_PROTOCOL_DELETE_DEVICE DeleteDevice;

11
MdePkg/Include/Protocol/UnicodeCollation.h
View File

@ -164,11 +164,10 @@ BOOLEAN
OUT CHAR8 *Fat
);
/**
@par Protocol Description:
The EFI_UNICODE_COLLATION_PROTOCOL is used to perform case-insensitive
comparisons of Unicode strings.
**/
///
/// The EFI_UNICODE_COLLATION_PROTOCOL is used to perform case-insensitive
/// comparisons of Unicode strings.
///
struct _EFI_UNICODE_COLLATION_PROTOCOL {
//
// general
@ -185,7 +184,7 @@ struct _EFI_UNICODE_COLLATION_PROTOCOL {
EFI_UNICODE_COLLATION_STRTOFAT StrToFat;
///
/// LanguagesA Null-terminated ASCII string array that contains one or more
/// A Null-terminated ASCII string array that contains one or more
/// language codes. This array is specified in RFC 4646 format.
///
CHAR8 *SupportedLanguages;

18
MdePkg/Include/Protocol/Usb2HostController.h
View File

@ -553,16 +553,14 @@ EFI_STATUS
IN EFI_USB_PORT_FEATURE PortFeature
);
/**
@par Protocol Description:
The EFI_USB2_HC_PROTOCOL provides USB host controller management, basic
data transactions over a USB bus, and USB root hub access. A device driver
that wishes to manage a USB bus in a system retrieves the EFI_USB2_HC_PROTOCOL
instance that is associated with the USB bus to be managed. A device handle
for a USB host controller will minimally contain an EFI_DEVICE_PATH_PROTOCOL
instance, and an EFI_USB2_HC_PROTOCOL instance.
**/
///
/// The EFI_USB2_HC_PROTOCOL provides USB host controller management, basic
/// data transactions over a USB bus, and USB root hub access. A device driver
/// that wishes to manage a USB bus in a system retrieves the EFI_USB2_HC_PROTOCOL
/// instance that is associated with the USB bus to be managed. A device handle
/// for a USB host controller will minimally contain an EFI_DEVICE_PATH_PROTOCOL
/// instance, and an EFI_USB2_HC_PROTOCOL instance.
///
struct _EFI_USB2_HC_PROTOCOL {
EFI_USB2_HC_PROTOCOL_GET_CAPABILITY GetCapability;
EFI_USB2_HC_PROTOCOL_RESET Reset;

Some files were not shown because too many files have changed in this diff Show More