[mirror_edk2.git] / MdePkg / Library / SmmIoLibSmmCpuIo2 / IoLib.c

/** @file\r
  I/O Library.\r
  The implementation of I/O operation for this library instance \r
  are based on EFI_CPU_IO_PROTOCOL.\r
  \r
  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php.\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "SmmCpuIoLibInternal.h"\r
\r
/**\r
  Reads registers in the EFI CPU I/O space.\r
\r
  Reads the I/O port specified by Port with registers width specified by Width.\r
  The read value is returned. If such operations are not supported, then ASSERT().\r
  This function must guarantee that all I/O read and write operations are serialized.\r
\r
  @param  Port          The base address of the I/O operation.\r
                        The caller is responsible for aligning the Address if required.\r
  @param  Width         The width of the I/O operation.\r
\r
  @return Data read from registers in the EFI CPU I/O space.\r
\r
**/\r
UINT64\r
EFIAPI\r
IoReadWorker (\r
  IN      UINTN                     Port,\r
  IN      EFI_SMM_IO_WIDTH          Width\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINT64                            Data;\r
\r
  Status = gSmst->SmmIo.Io.Read (&gSmst->SmmIo, Width, Port, 1, &Data);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Data;\r
}\r
\r
/**\r
  Writes registers in the EFI CPU I/O space.\r
\r
  Writes the I/O port specified by Port with registers width and value specified by Width\r
  and Data respectively.  Data is returned. If such operations are not supported, then ASSERT().\r
  This function must guarantee that all I/O read and write operations are serialized.\r
\r
  @param  Port          The base address of the I/O operation.\r
                        The caller is responsible for aligning the Address if required.\r
  @param  Width         The width of the I/O operation.\r
  @param  Data          The value to write to the I/O port.\r
\r
  @return The parameter of Data.\r
\r
**/\r
UINT64\r
EFIAPI\r
IoWriteWorker (\r
  IN      UINTN                     Port,\r
  IN      EFI_SMM_IO_WIDTH          Width,\r
  IN      UINT64                    Data\r
  )\r
{\r
  EFI_STATUS                        Status;\r
\r
  Status = gSmst->SmmIo.Io.Write (&gSmst->SmmIo, Width, Port, 1, &Data);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Data;\r
}\r
\r
/**\r
  Reads memory-mapped registers in the EFI system memory space.\r
\r
  Reads the MMIO registers specified by Address with registers width specified by Width.\r
  The read value is returned. If such operations are not supported, then ASSERT().\r
  This function must guarantee that all MMIO read and write operations are serialized.\r
\r
  @param  Address       The MMIO register to read.\r
                        The caller is responsible for aligning the Address if required.\r
  @param  Width         The width of the I/O operation.\r
\r
  @return Data read from registers in the EFI system memory space.\r
\r
**/\r
UINT64\r
EFIAPI\r
MmioReadWorker (\r
  IN      UINTN                     Address,\r
  IN      EFI_SMM_IO_WIDTH          Width\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINT64                            Data;\r
\r
  Status = gSmst->SmmIo.Mem.Read (&gSmst->SmmIo, Width, Address, 1, &Data);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Data;\r
}\r
\r
/**\r
  Writes memory-mapped registers in the EFI system memory space.\r
\r
  Writes the MMIO registers specified by Address with registers width and value specified by Width\r
  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().\r
  This function must guarantee that all MMIO read and write operations are serialized.\r
\r
  @param  Address       The MMIO register to read.\r
                        The caller is responsible for aligning the Address if required.\r
  @param  Width         The width of the I/O operation.\r
  @param  Data          The value to write to the I/O port.\r
  \r
  @return Data read from registers in the EFI system memory space.\r
\r
**/\r
UINT64\r
EFIAPI\r
MmioWriteWorker (\r
  IN      UINTN                     Address,\r
  IN      EFI_SMM_IO_WIDTH          Width,\r
  IN      UINT64                    Data\r
  )\r
{\r
  EFI_STATUS                        Status;\r
\r
  Status = gSmst->SmmIo.Mem.Write (&gSmst->SmmIo, Width, Address, 1, &Data);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Data;\r
}\r
\r
/**\r
  Reads an 8-bit I/O port.\r
\r
  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.\r
  This function must guarantee that all I/O read and write operations are\r
  serialized.\r
\r
  If 8-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT8\r
EFIAPI\r
IoRead8 (\r
  IN      UINTN                     Port\r
  )\r
{\r
  return (UINT8)IoReadWorker (Port, SMM_IO_UINT8);\r
}\r
\r
/**\r
  Writes an 8-bit I/O port.\r
\r
  Writes the 8-bit I/O port specified by Port with the value specified by Value\r
  and returns Value. This function must guarantee that all I/O read and write\r
  operations are serialized.\r
\r
  If 8-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to write.\r
  @param  Value The value to write to the I/O port.\r
\r
  @return The value written the I/O port.\r
\r
**/\r
UINT8\r
EFIAPI\r
IoWrite8 (\r
  IN      UINTN                     Port,\r
  IN      UINT8                     Value\r
  )\r
{\r
  return (UINT8)IoWriteWorker (Port, SMM_IO_UINT8, Value);\r
}\r
\r
/**\r
  Reads a 16-bit I/O port.\r
\r
  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.\r
  This function must guarantee that all I/O read and write operations are\r
  serialized.\r
\r
  If Port is not aligned on a 16-bit boundary, then ASSERT().\r
 \r
  If 16-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT16\r
EFIAPI\r
IoRead16 (\r
  IN      UINTN                     Port\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 16-bit boundary.\r
  //\r
  ASSERT ((Port & 1) == 0);\r
  return (UINT16)IoReadWorker (Port, SMM_IO_UINT16);\r
}\r
\r
/**\r
  Writes a 16-bit I/O port.\r
\r
  Writes the 16-bit I/O port specified by Port with the value specified by Value\r
  and returns Value. This function must guarantee that all I/O read and write\r
  operations are serialized.\r
\r
  If Port is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  If 16-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to write.\r
  @param  Value The value to write to the I/O port.\r
\r
  @return The value written the I/O port.\r
\r
**/\r
UINT16\r
EFIAPI\r
IoWrite16 (\r
  IN      UINTN                     Port,\r
  IN      UINT16                    Value\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 16-bit boundary.\r
  //\r
  ASSERT ((Port & 1) == 0);\r
  return (UINT16)IoWriteWorker (Port, SMM_IO_UINT16, Value);\r
}\r
\r
/**\r
  Reads a 32-bit I/O port.\r
\r
  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.\r
  This function must guarantee that all I/O read and write operations are\r
  serialized.\r
 \r
  If Port is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  If 32-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT32\r
EFIAPI\r
IoRead32 (\r
  IN      UINTN                     Port\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 32-bit boundary.\r
  //\r
  ASSERT ((Port & 3) == 0);\r
  return (UINT32)IoReadWorker (Port, SMM_IO_UINT32);\r
}\r
\r
/**\r
  Writes a 32-bit I/O port.\r
\r
  Writes the 32-bit I/O port specified by Port with the value specified by Value\r
  and returns Value. This function must guarantee that all I/O read and write\r
  operations are serialized.\r
\r
  If Port is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  If 32-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to write.\r
  @param  Value The value to write to the I/O port.\r
\r
  @return The value written the I/O port.\r
\r
**/\r
UINT32\r
EFIAPI\r
IoWrite32 (\r
  IN      UINTN                     Port,\r
  IN      UINT32                    Value\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 32-bit boundary.\r
  //\r
  ASSERT ((Port & 3) == 0);\r
  return (UINT32)IoWriteWorker (Port, SMM_IO_UINT32, Value);\r
}\r
\r
/**\r
  Reads a 64-bit I/O port.\r
\r
  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.\r
  This function must guarantee that all I/O read and write operations are\r
  serialized.\r
\r
  If Port is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  If 64-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT64\r
EFIAPI\r
IoRead64 (\r
  IN      UINTN                     Port\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 64-bit boundary.\r
  //\r
  ASSERT ((Port & 7) == 0);\r
  return IoReadWorker (Port, SMM_IO_UINT64);\r
}\r
\r
/**\r
  Writes a 64-bit I/O port.\r
\r
  Writes the 64-bit I/O port specified by Port with the value specified by Value\r
  and returns Value. This function must guarantee that all I/O read and write\r
  operations are serialized.\r
\r
  If Port is not aligned on a 64-bit boundary, then ASSERT().\r
 \r
  If 64-bit I/O port operations are not supported, then ASSERT().\r
\r
  @param  Port  The I/O port to write.\r
  @param  Value The value to write to the I/O port.\r
\r
  @return The value written the I/O port.\r
\r
**/\r
UINT64\r
EFIAPI\r
IoWrite64 (\r
  IN      UINTN                     Port,\r
  IN      UINT64                    Value\r
  )\r
{\r
  //\r
  // Make sure Port is aligned on a 64-bit boundary.\r
  //\r
  ASSERT ((Port & 7) == 0);\r
  return IoWriteWorker (Port, SMM_IO_UINT64, Value);\r
}\r
\r
/**\r
  Reads an 8-bit MMIO register.\r
\r
  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is\r
  returned. This function must guarantee that all MMIO read and write\r
  operations are serialized.\r
\r
  If 8-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT8\r
EFIAPI\r
MmioRead8 (\r
  IN      UINTN                     Address\r
  )\r
{\r
  return (UINT8)MmioReadWorker (Address, SMM_IO_UINT8);\r
}\r
\r
/**\r
  Writes an 8-bit MMIO register.\r
\r
  Writes the 8-bit MMIO register specified by Address with the value specified\r
  by Value and returns Value. This function must guarantee that all MMIO read\r
  and write operations are serialized.\r
\r
  If 8-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to write.\r
  @param  Value   The value to write to the MMIO register.\r
\r
**/\r
UINT8\r
EFIAPI\r
MmioWrite8 (\r
  IN      UINTN                     Address,\r
  IN      UINT8                     Value\r
  )\r
{\r
  return (UINT8)MmioWriteWorker (Address, SMM_IO_UINT8, Value);\r
}\r
\r
/**\r
  Reads a 16-bit MMIO register.\r
\r
  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is\r
  returned. This function must guarantee that all MMIO read and write\r
  operations are serialized.\r
\r
  If Address is not aligned on a 16-bit boundary, then ASSERT().\r
 \r
  If 16-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT16\r
EFIAPI\r
MmioRead16 (\r
  IN      UINTN                     Address\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 16-bit boundary.\r
  //\r
  ASSERT ((Address & 1) == 0);\r
  return (UINT16)MmioReadWorker (Address, SMM_IO_UINT16);\r
}\r
\r
/**\r
  Writes a 16-bit MMIO register.\r
\r
  Writes the 16-bit MMIO register specified by Address with the value specified\r
  by Value and returns Value. This function must guarantee that all MMIO read\r
  and write operations are serialized.\r
\r
  If Address is not aligned on a 16-bit boundary, then ASSERT().\r
 \r
  If 16-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to write.\r
  @param  Value   The value to write to the MMIO register.\r
\r
**/\r
UINT16\r
EFIAPI\r
MmioWrite16 (\r
  IN      UINTN                     Address,\r
  IN      UINT16                    Value\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 16-bit boundary.\r
  //\r
  ASSERT ((Address & 1) == 0);\r
  return (UINT16)MmioWriteWorker (Address, SMM_IO_UINT16, Value);\r
}\r
\r
/**\r
  Reads a 32-bit MMIO register.\r
\r
  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is\r
  returned. This function must guarantee that all MMIO read and write\r
  operations are serialized.\r
\r
  If Address is not aligned on a 32-bit boundary, then ASSERT().\r
  \r
  If 32-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT32\r
EFIAPI\r
MmioRead32 (\r
  IN      UINTN                     Address\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 32-bit boundary.\r
  //\r
  ASSERT ((Address & 3) == 0);\r
  return (UINT32)MmioReadWorker (Address, SMM_IO_UINT32);\r
}\r
\r
/**\r
  Writes a 32-bit MMIO register.\r
\r
  Writes the 32-bit MMIO register specified by Address with the value specified\r
  by Value and returns Value. This function must guarantee that all MMIO read\r
  and write operations are serialized.\r
\r
  If Address is not aligned on a 32-bit boundary, then ASSERT().\r
 \r
  If 32-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to write.\r
  @param  Value   The value to write to the MMIO register.\r
\r
**/\r
UINT32\r
EFIAPI\r
MmioWrite32 (\r
  IN      UINTN                     Address,\r
  IN      UINT32                    Value\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 32-bit boundary.\r
  //\r
  ASSERT ((Address & 3) == 0);\r
  return (UINT32)MmioWriteWorker (Address, SMM_IO_UINT32, Value);\r
}\r
\r
/**\r
  Reads a 64-bit MMIO register.\r
\r
  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is\r
  returned. This function must guarantee that all MMIO read and write\r
  operations are serialized.\r
\r
  If Address is not aligned on a 64-bit boundary, then ASSERT().\r
 \r
  If 64-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to read.\r
\r
  @return The value read.\r
\r
**/\r
UINT64\r
EFIAPI\r
MmioRead64 (\r
  IN      UINTN                     Address\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 64-bit boundary.\r
  //\r
  ASSERT ((Address & 7) == 0);\r
  return (UINT64)MmioReadWorker (Address, SMM_IO_UINT64);\r
}\r
\r
/**\r
  Writes a 64-bit MMIO register.\r
\r
  Writes the 64-bit MMIO register specified by Address with the value specified\r
  by Value and returns Value. This function must guarantee that all MMIO read\r
  and write operations are serialized.\r
\r
  If Address is not aligned on a 64-bit boundary, then ASSERT().\r
 \r
  If 64-bit MMIO register operations are not supported, then ASSERT().\r
\r
  @param  Address The MMIO register to write.\r
  @param  Value   The value to write to the MMIO register.\r
\r
**/\r
UINT64\r
EFIAPI\r
MmioWrite64 (\r
  IN      UINTN                     Address,\r
  IN      UINT64                    Value\r
  )\r
{\r
  //\r
  // Make sure Address is aligned on a 64-bit boundary.\r
  //\r
  ASSERT ((Address & 7) == 0);\r
  return (UINT64)MmioWriteWorker (Address, SMM_IO_UINT64, Value);\r
}\r
Commit	Line	Data
b7c5912a	1	/** @file\r
	2	I/O Library.\r
	3	The implementation of I/O operation for this library instance \r
	4	are based on EFI_CPU_IO_PROTOCOL.\r
	5	\r
19388d29 HT	6	Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>\r
19388d29 HT	7	This program and the accompanying materials\r
b7c5912a	8	are licensed and made available under the terms and conditions of the BSD License\r
b7c5912a	9	which accompanies this distribution. The full text of the license may be found at\r
2fc59a00	10	http://opensource.org/licenses/bsd-license.php.\r
b7c5912a	11	\r
	12	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	13	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	14	\r
b7c5912a	15	**/\r
b7c5912a	16	\r
b7c5912a	17	#include "SmmCpuIoLibInternal.h"\r
b7c5912a	18	\r
b7c5912a	19	/**\r
	20	Reads registers in the EFI CPU I/O space.\r
	21	\r
	22	Reads the I/O port specified by Port with registers width specified by Width.\r
	23	The read value is returned. If such operations are not supported, then ASSERT().\r
	24	This function must guarantee that all I/O read and write operations are serialized.\r
	25	\r
	26	@param Port The base address of the I/O operation.\r
	27	The caller is responsible for aligning the Address if required.\r
	28	@param Width The width of the I/O operation.\r
	29	\r
	30	@return Data read from registers in the EFI CPU I/O space.\r
	31	\r
	32	**/\r
	33	UINT64\r
	34	EFIAPI\r
	35	IoReadWorker (\r
	36	IN UINTN Port,\r
	37	IN EFI_SMM_IO_WIDTH Width\r
	38	)\r
	39	{\r
	40	EFI_STATUS Status;\r
	41	UINT64 Data;\r
	42	\r
112af426	43	Status = gSmst->SmmIo.Io.Read (&gSmst->SmmIo, Width, Port, 1, &Data);\r
b7c5912a	44	ASSERT_EFI_ERROR (Status);\r
	45	\r
	46	return Data;\r
	47	}\r
	48	\r
	49	/**\r
	50	Writes registers in the EFI CPU I/O space.\r
	51	\r
	52	Writes the I/O port specified by Port with registers width and value specified by Width\r
	53	and Data respectively. Data is returned. If such operations are not supported, then ASSERT().\r
	54	This function must guarantee that all I/O read and write operations are serialized.\r
	55	\r
	56	@param Port The base address of the I/O operation.\r
	57	The caller is responsible for aligning the Address if required.\r
	58	@param Width The width of the I/O operation.\r
	59	@param Data The value to write to the I/O port.\r
	60	\r
a750b4ae	61	@return The parameter of Data.\r
b7c5912a	62	\r
	63	**/\r
	64	UINT64\r
	65	EFIAPI\r
	66	IoWriteWorker (\r
	67	IN UINTN Port,\r
	68	IN EFI_SMM_IO_WIDTH Width,\r
	69	IN UINT64 Data\r
	70	)\r
	71	{\r
	72	EFI_STATUS Status;\r
	73	\r
112af426	74	Status = gSmst->SmmIo.Io.Write (&gSmst->SmmIo, Width, Port, 1, &Data);\r
b7c5912a	75	ASSERT_EFI_ERROR (Status);\r
	76	\r
	77	return Data;\r
	78	}\r
	79	\r
	80	/**\r
	81	Reads memory-mapped registers in the EFI system memory space.\r
	82	\r
	83	Reads the MMIO registers specified by Address with registers width specified by Width.\r
	84	The read value is returned. If such operations are not supported, then ASSERT().\r
	85	This function must guarantee that all MMIO read and write operations are serialized.\r
	86	\r
	87	@param Address The MMIO register to read.\r
	88	The caller is responsible for aligning the Address if required.\r
	89	@param Width The width of the I/O operation.\r
	90	\r
	91	@return Data read from registers in the EFI system memory space.\r
	92	\r
	93	**/\r
	94	UINT64\r
	95	EFIAPI\r
	96	MmioReadWorker (\r
	97	IN UINTN Address,\r
	98	IN EFI_SMM_IO_WIDTH Width\r
	99	)\r
	100	{\r
	101	EFI_STATUS Status;\r
	102	UINT64 Data;\r
	103	\r
112af426	104	Status = gSmst->SmmIo.Mem.Read (&gSmst->SmmIo, Width, Address, 1, &Data);\r
b7c5912a	105	ASSERT_EFI_ERROR (Status);\r
	106	\r
	107	return Data;\r
	108	}\r
	109	\r
	110	/**\r
	111	Writes memory-mapped registers in the EFI system memory space.\r
	112	\r
	113	Writes the MMIO registers specified by Address with registers width and value specified by Width\r
	114	and Data respectively. Data is returned. If such operations are not supported, then ASSERT().\r
	115	This function must guarantee that all MMIO read and write operations are serialized.\r
	116	\r
	117	@param Address The MMIO register to read.\r
	118	The caller is responsible for aligning the Address if required.\r
	119	@param Width The width of the I/O operation.\r
	120	@param Data The value to write to the I/O port.\r
	121	\r
	122	@return Data read from registers in the EFI system memory space.\r
	123	\r
	124	**/\r
	125	UINT64\r
	126	EFIAPI\r
	127	MmioWriteWorker (\r
	128	IN UINTN Address,\r
	129	IN EFI_SMM_IO_WIDTH Width,\r
	130	IN UINT64 Data\r
	131	)\r
	132	{\r
	133	EFI_STATUS Status;\r
	134	\r
112af426	135	Status = gSmst->SmmIo.Mem.Write (&gSmst->SmmIo, Width, Address, 1, &Data);\r
b7c5912a	136	ASSERT_EFI_ERROR (Status);\r
	137	\r
	138	return Data;\r
	139	}\r
	140	\r
	141	/**\r
	142	Reads an 8-bit I/O port.\r
	143	\r
	144	Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.\r
	145	This function must guarantee that all I/O read and write operations are\r
	146	serialized.\r
	147	\r
	148	If 8-bit I/O port operations are not supported, then ASSERT().\r
	149	\r
	150	@param Port The I/O port to read.\r
	151	\r
	152	@return The value read.\r
	153	\r
	154	**/\r
	155	UINT8\r
	156	EFIAPI\r
	157	IoRead8 (\r
	158	IN UINTN Port\r
	159	)\r
	160	{\r
	161	return (UINT8)IoReadWorker (Port, SMM_IO_UINT8);\r
	162	}\r
	163	\r
	164	/**\r
	165	Writes an 8-bit I/O port.\r
	166	\r
	167	Writes the 8-bit I/O port specified by Port with the value specified by Value\r
	168	and returns Value. This function must guarantee that all I/O read and write\r
	169	operations are serialized.\r
	170	\r
	171	If 8-bit I/O port operations are not supported, then ASSERT().\r
	172	\r
	173	@param Port The I/O port to write.\r
	174	@param Value The value to write to the I/O port.\r
	175	\r
	176	@return The value written the I/O port.\r
	177	\r
	178	**/\r
	179	UINT8\r
	180	EFIAPI\r
	181	IoWrite8 (\r
	182	IN UINTN Port,\r
	183	IN UINT8 Value\r
	184	)\r
	185	{\r
	186	return (UINT8)IoWriteWorker (Port, SMM_IO_UINT8, Value);\r
	187	}\r
	188	\r
	189	/**\r
	190	Reads a 16-bit I/O port.\r
	191	\r
	192	Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.\r
	193	This function must guarantee that all I/O read and write operations are\r
	194	serialized.\r
	195	\r
	196	If Port is not aligned on a 16-bit boundary, then ASSERT().\r
	197	\r
	198	If 16-bit I/O port operations are not supported, then ASSERT().\r
	199	\r
200	@param Port The I/O port to read.\r
201	\r
202	@return The value read.\r
203	\r
204	**/\r
205	UINT16\r
206	EFIAPI\r
207	IoRead16 (\r
208	IN UINTN Port\r
209	)\r
210	{\r
211	//\r
212	// Make sure Port is aligned on a 16-bit boundary.\r
213	//\r
214	ASSERT ((Port & 1) == 0);\r
215	return (UINT16)IoReadWorker (Port, SMM_IO_UINT16);\r
216	}\r
217	\r
218	/**\r
219	Writes a 16-bit I/O port.\r
220	\r
221	Writes the 16-bit I/O port specified by Port with the value specified by Value\r
222	and returns Value. This function must guarantee that all I/O read and write\r
223	operations are serialized.\r
224	\r
225	If Port is not aligned on a 16-bit boundary, then ASSERT().\r
226	\r
227	If 16-bit I/O port operations are not supported, then ASSERT().\r
228	\r
229	@param Port The I/O port to write.\r
230	@param Value The value to write to the I/O port.\r
231	\r
232	@return The value written the I/O port.\r
233	\r
234	**/\r
235	UINT16\r
236	EFIAPI\r
237	IoWrite16 (\r
238	IN UINTN Port,\r
239	IN UINT16 Value\r
240	)\r
241	{\r
242	//\r
243	// Make sure Port is aligned on a 16-bit boundary.\r
244	//\r
245	ASSERT ((Port & 1) == 0);\r
246	return (UINT16)IoWriteWorker (Port, SMM_IO_UINT16, Value);\r
247	}\r
248	\r
249	/**\r
250	Reads a 32-bit I/O port.\r
251	\r
252	Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.\r
253	This function must guarantee that all I/O read and write operations are\r
254	serialized.\r
255	\r
256	If Port is not aligned on a 32-bit boundary, then ASSERT().\r
257	\r
258	If 32-bit I/O port operations are not supported, then ASSERT().\r
259	\r
260	@param Port The I/O port to read.\r
261	\r
262	@return The value read.\r
263	\r
264	**/\r
265	UINT32\r
266	EFIAPI\r
267	IoRead32 (\r
268	IN UINTN Port\r
269	)\r
270	{\r
271	//\r
272	// Make sure Port is aligned on a 32-bit boundary.\r
273	//\r
274	ASSERT ((Port & 3) == 0);\r
275	return (UINT32)IoReadWorker (Port, SMM_IO_UINT32);\r
276	}\r
277	\r
278	/**\r
279	Writes a 32-bit I/O port.\r
280	\r
281	Writes the 32-bit I/O port specified by Port with the value specified by Value\r
282	and returns Value. This function must guarantee that all I/O read and write\r
283	operations are serialized.\r
284	\r
285	If Port is not aligned on a 32-bit boundary, then ASSERT().\r
286	\r
287	If 32-bit I/O port operations are not supported, then ASSERT().\r
288	\r
289	@param Port The I/O port to write.\r
290	@param Value The value to write to the I/O port.\r
291	\r
292	@return The value written the I/O port.\r
293	\r
294	**/\r
295	UINT32\r
296	EFIAPI\r
297	IoWrite32 (\r
298	IN UINTN Port,\r
299	IN UINT32 Value\r
300	)\r
301	{\r
302	//\r
303	// Make sure Port is aligned on a 32-bit boundary.\r
304	//\r
305	ASSERT ((Port & 3) == 0);\r
306	return (UINT32)IoWriteWorker (Port, SMM_IO_UINT32, Value);\r
307	}\r
308	\r
309	/**\r
310	Reads a 64-bit I/O port.\r
311	\r
312	Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.\r
313	This function must guarantee that all I/O read and write operations are\r
314	serialized.\r
315	\r
316	If Port is not aligned on a 64-bit boundary, then ASSERT().\r
317	\r
318	If 64-bit I/O port operations are not supported, then ASSERT().\r
319	\r
320	@param Port The I/O port to read.\r
321	\r
322	@return The value read.\r
323	\r
324	**/\r
325	UINT64\r
326	EFIAPI\r
327	IoRead64 (\r
328	IN UINTN Port\r
329	)\r
330	{\r
331	//\r
332	// Make sure Port is aligned on a 64-bit boundary.\r
333	//\r
334	ASSERT ((Port & 7) == 0);\r
335	return IoReadWorker (Port, SMM_IO_UINT64);\r
336	}\r
337	\r
338	/**\r
339	Writes a 64-bit I/O port.\r
340	\r
341	Writes the 64-bit I/O port specified by Port with the value specified by Value\r
342	and returns Value. This function must guarantee that all I/O read and write\r
343	operations are serialized.\r
344	\r
345	If Port is not aligned on a 64-bit boundary, then ASSERT().\r
346	\r
347	If 64-bit I/O port operations are not supported, then ASSERT().\r
348	\r
349	@param Port The I/O port to write.\r
350	@param Value The value to write to the I/O port.\r
351	\r
352	@return The value written the I/O port.\r
353	\r
354	**/\r
355	UINT64\r
356	EFIAPI\r
357	IoWrite64 (\r
358	IN UINTN Port,\r
359	IN UINT64 Value\r
360	)\r
361	{\r
362	//\r
363	// Make sure Port is aligned on a 64-bit boundary.\r
364	//\r
365	ASSERT ((Port & 7) == 0);\r
366	return IoWriteWorker (Port, SMM_IO_UINT64, Value);\r
367	}\r
368	\r
369	/**\r
370	Reads an 8-bit MMIO register.\r
371	\r
372	Reads the 8-bit MMIO register specified by Address. The 8-bit read value is\r
373	returned. This function must guarantee that all MMIO read and write\r
374	operations are serialized.\r
375	\r
376	If 8-bit MMIO register operations are not supported, then ASSERT().\r
377	\r
378	@param Address The MMIO register to read.\r
379	\r
380	@return The value read.\r
381	\r
382	**/\r
383	UINT8\r
384	EFIAPI\r
385	MmioRead8 (\r
386	IN UINTN Address\r
387	)\r
388	{\r
389	return (UINT8)MmioReadWorker (Address, SMM_IO_UINT8);\r
390	}\r
391	\r
392	/**\r
393	Writes an 8-bit MMIO register.\r
394	\r
395	Writes the 8-bit MMIO register specified by Address with the value specified\r
396	by Value and returns Value. This function must guarantee that all MMIO read\r
397	and write operations are serialized.\r
398	\r
399	If 8-bit MMIO register operations are not supported, then ASSERT().\r
400	\r
401	@param Address The MMIO register to write.\r
402	@param Value The value to write to the MMIO register.\r
403	\r
404	**/\r
405	UINT8\r
406	EFIAPI\r
407	MmioWrite8 (\r
408	IN UINTN Address,\r
409	IN UINT8 Value\r
410	)\r
411	{\r
412	return (UINT8)MmioWriteWorker (Address, SMM_IO_UINT8, Value);\r
413	}\r
414	\r
415	/**\r
416	Reads a 16-bit MMIO register.\r
417	\r
418	Reads the 16-bit MMIO register specified by Address. The 16-bit read value is\r
419	returned. This function must guarantee that all MMIO read and write\r
420	operations are serialized.\r
421	\r
422	If Address is not aligned on a 16-bit boundary, then ASSERT().\r
423	\r
424	If 16-bit MMIO register operations are not supported, then ASSERT().\r
425	\r
426	@param Address The MMIO register to read.\r
427	\r
428	@return The value read.\r
429	\r
430	**/\r
431	UINT16\r
432	EFIAPI\r
433	MmioRead16 (\r
434	IN UINTN Address\r
435	)\r
436	{\r
437	//\r
438	// Make sure Address is aligned on a 16-bit boundary.\r
439	//\r
440	ASSERT ((Address & 1) == 0);\r
441	return (UINT16)MmioReadWorker (Address, SMM_IO_UINT16);\r
442	}\r
443	\r
444	/**\r
445	Writes a 16-bit MMIO register.\r
446	\r
447	Writes the 16-bit MMIO register specified by Address with the value specified\r
448	by Value and returns Value. This function must guarantee that all MMIO read\r
449	and write operations are serialized.\r
450	\r
451	If Address is not aligned on a 16-bit boundary, then ASSERT().\r
452	\r
453	If 16-bit MMIO register operations are not supported, then ASSERT().\r
454	\r
455	@param Address The MMIO register to write.\r
456	@param Value The value to write to the MMIO register.\r
457	\r
458	**/\r
459	UINT16\r
460	EFIAPI\r
461	MmioWrite16 (\r
462	IN UINTN Address,\r
463	IN UINT16 Value\r
464	)\r
465	{\r
466	//\r
467	// Make sure Address is aligned on a 16-bit boundary.\r
468	//\r
469	ASSERT ((Address & 1) == 0);\r
470	return (UINT16)MmioWriteWorker (Address, SMM_IO_UINT16, Value);\r
471	}\r
472	\r
473	/**\r
474	Reads a 32-bit MMIO register.\r
475	\r
476	Reads the 32-bit MMIO register specified by Address. The 32-bit read value is\r
477	returned. This function must guarantee that all MMIO read and write\r
478	operations are serialized.\r
479	\r
480	If Address is not aligned on a 32-bit boundary, then ASSERT().\r
481	\r
482	If 32-bit MMIO register operations are not supported, then ASSERT().\r
483	\r
484	@param Address The MMIO register to read.\r
485	\r
486	@return The value read.\r
487	\r
488	**/\r
489	UINT32\r
490	EFIAPI\r
491	MmioRead32 (\r
492	IN UINTN Address\r
493	)\r
494	{\r
495	//\r
496	// Make sure Address is aligned on a 32-bit boundary.\r
497	//\r
498	ASSERT ((Address & 3) == 0);\r
499	return (UINT32)MmioReadWorker (Address, SMM_IO_UINT32);\r
500	}\r
501	\r
502	/**\r
503	Writes a 32-bit MMIO register.\r
504	\r
505	Writes the 32-bit MMIO register specified by Address with the value specified\r
506	by Value and returns Value. This function must guarantee that all MMIO read\r
507	and write operations are serialized.\r
508	\r
509	If Address is not aligned on a 32-bit boundary, then ASSERT().\r
510	\r
511	If 32-bit MMIO register operations are not supported, then ASSERT().\r
512	\r
513	@param Address The MMIO register to write.\r
514	@param Value The value to write to the MMIO register.\r
515	\r
516	**/\r
517	UINT32\r
518	EFIAPI\r
519	MmioWrite32 (\r
520	IN UINTN Address,\r
521	IN UINT32 Value\r
522	)\r
523	{\r
524	//\r
525	// Make sure Address is aligned on a 32-bit boundary.\r
526	//\r
527	ASSERT ((Address & 3) == 0);\r
528	return (UINT32)MmioWriteWorker (Address, SMM_IO_UINT32, Value);\r
529	}\r
530	\r
531	/**\r
532	Reads a 64-bit MMIO register.\r
533	\r
534	Reads the 64-bit MMIO register specified by Address. The 64-bit read value is\r
535	returned. This function must guarantee that all MMIO read and write\r
536	operations are serialized.\r
537	\r
538	If Address is not aligned on a 64-bit boundary, then ASSERT().\r
539	\r
540	If 64-bit MMIO register operations are not supported, then ASSERT().\r
541	\r
542	@param Address The MMIO register to read.\r
543	\r
544	@return The value read.\r
545	\r
546	**/\r
547	UINT64\r
548	EFIAPI\r
549	MmioRead64 (\r
550	IN UINTN Address\r
551	)\r
552	{\r
553	//\r
554	// Make sure Address is aligned on a 64-bit boundary.\r
555	//\r
556	ASSERT ((Address & 7) == 0);\r
557	return (UINT64)MmioReadWorker (Address, SMM_IO_UINT64);\r
558	}\r
559	\r
560	/**\r
561	Writes a 64-bit MMIO register.\r
562	\r
563	Writes the 64-bit MMIO register specified by Address with the value specified\r
564	by Value and returns Value. This function must guarantee that all MMIO read\r
565	and write operations are serialized.\r
566	\r
567	If Address is not aligned on a 64-bit boundary, then ASSERT().\r
568	\r
569	If 64-bit MMIO register operations are not supported, then ASSERT().\r
570	\r
571	@param Address The MMIO register to write.\r
572	@param Value The value to write to the MMIO register.\r
573	\r
574	**/\r
575	UINT64\r
576	EFIAPI\r
577	MmioWrite64 (\r
578	IN UINTN Address,\r
579	IN UINT64 Value\r
580	)\r
581	{\r
582	//\r
583	// Make sure Address is aligned on a 64-bit boundary.\r
584	//\r
585	ASSERT ((Address & 7) == 0);\r
586	return (UINT64)MmioWriteWorker (Address, SMM_IO_UINT64, Value);\r
587	}\r