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

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