[mirror_edk2.git] / MdePkg / Library / BaseIoLibIntrinsic / IoLibArm.c

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