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

/** @file\r
  I/O Library MMIO Buffer Functions.\r
  The implementations are based on EFI_PEI_SERVICE->CpuIo interface.\r
\r
  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\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
  Copy data from MMIO region to system memory by using 8-bit access.\r
\r
  Copy data from MMIO region specified by starting address StartAddress\r
  to system memory specified by Buffer by using 8-bit access. The total\r
  number of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied from.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer receiving the data read.\r
\r
  @return Buffer\r
\r
**/\r
UINT8 *\r
EFIAPI\r
MmioReadBuffer8 (\r
  IN  UINTN  StartAddress,\r
  IN  UINTN  Length,\r
  OUT UINT8  *Buffer\r
  )\r
{\r
  UINT8  *ReturnBuffer;\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ReturnBuffer = Buffer;\r
\r
  while (Length-- != 0) {\r
    *(Buffer++) = MmioRead8 (StartAddress++);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from MMIO region to system memory by using 16-bit access.\r
\r
  Copy data from MMIO region specified by starting address StartAddress\r
  to system memory specified by Buffer by using 16-bit access. The total\r
  number of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 16-bit boundary, then ASSERT().\r
  If Buffer is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied from.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer receiving the data read.\r
\r
  @return Buffer\r
\r
**/\r
UINT16 *\r
EFIAPI\r
MmioReadBuffer16 (\r
  IN  UINTN   StartAddress,\r
  IN  UINTN   Length,\r
  OUT UINT16  *Buffer\r
  )\r
{\r
  UINT16  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);\r
\r
  ReturnBuffer = Buffer;\r
\r
  while (Length != 0) {\r
    *(Buffer++)   = MmioRead16 (StartAddress);\r
    StartAddress += sizeof (UINT16);\r
    Length       -= sizeof (UINT16);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from MMIO region to system memory by using 32-bit access.\r
\r
  Copy data from MMIO region specified by starting address StartAddress\r
  to system memory specified by Buffer by using 32-bit access. The total\r
  number of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 32-bit boundary, then ASSERT().\r
  If Buffer is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied from.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer receiving the data read.\r
\r
  @return Buffer\r
\r
**/\r
UINT32 *\r
EFIAPI\r
MmioReadBuffer32 (\r
  IN  UINTN   StartAddress,\r
  IN  UINTN   Length,\r
  OUT UINT32  *Buffer\r
  )\r
{\r
  UINT32  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);\r
\r
  ReturnBuffer = Buffer;\r
\r
  while (Length != 0) {\r
    *(Buffer++)   = MmioRead32 (StartAddress);\r
    StartAddress += sizeof (UINT32);\r
    Length       -= sizeof (UINT32);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from MMIO region to system memory by using 64-bit access.\r
\r
  Copy data from MMIO region specified by starting address StartAddress\r
  to system memory specified by Buffer by using 64-bit access. The total\r
  number of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 64-bit boundary, then ASSERT().\r
  If Buffer is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied from.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer receiving the data read.\r
\r
  @return Buffer\r
\r
**/\r
UINT64 *\r
EFIAPI\r
MmioReadBuffer64 (\r
  IN  UINTN   StartAddress,\r
  IN  UINTN   Length,\r
  OUT UINT64  *Buffer\r
  )\r
{\r
  UINT64  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);\r
\r
  ReturnBuffer = Buffer;\r
\r
  while (Length != 0) {\r
    *(Buffer++)   = MmioRead64 (StartAddress);\r
    StartAddress += sizeof (UINT64);\r
    Length       -= sizeof (UINT64);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from system memory to MMIO region by using 8-bit access.\r
\r
  Copy data from system memory specified by Buffer to MMIO region specified\r
  by starting address StartAddress by using 8-bit access. The total number\r
  of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied to.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer containing the data to write.\r
\r
  @return Buffer\r
\r
**/\r
UINT8 *\r
EFIAPI\r
MmioWriteBuffer8 (\r
  IN  UINTN        StartAddress,\r
  IN  UINTN        Length,\r
  IN  CONST UINT8  *Buffer\r
  )\r
{\r
  VOID  *ReturnBuffer;\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ReturnBuffer = (UINT8 *)Buffer;\r
\r
  while (Length-- != 0) {\r
    MmioWrite8 (StartAddress++, *(Buffer++));\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from system memory to MMIO region by using 16-bit access.\r
\r
  Copy data from system memory specified by Buffer to MMIO region specified\r
  by starting address StartAddress by using 16-bit access. The total number\r
  of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  If Buffer is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied to.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer containing the data to write.\r
\r
  @return Buffer\r
\r
**/\r
UINT16 *\r
EFIAPI\r
MmioWriteBuffer16 (\r
  IN  UINTN         StartAddress,\r
  IN  UINTN         Length,\r
  IN  CONST UINT16  *Buffer\r
  )\r
{\r
  UINT16  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);\r
\r
  ReturnBuffer = (UINT16 *)Buffer;\r
\r
  while (Length != 0) {\r
    MmioWrite16 (StartAddress, *(Buffer++));\r
\r
    StartAddress += sizeof (UINT16);\r
    Length       -= sizeof (UINT16);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from system memory to MMIO region by using 32-bit access.\r
\r
  Copy data from system memory specified by Buffer to MMIO region specified\r
  by starting address StartAddress by using 32-bit access. The total number\r
  of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  If Buffer is not aligned on a 32-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied to.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer containing the data to write.\r
\r
  @return Buffer\r
\r
**/\r
UINT32 *\r
EFIAPI\r
MmioWriteBuffer32 (\r
  IN  UINTN         StartAddress,\r
  IN  UINTN         Length,\r
  IN  CONST UINT32  *Buffer\r
  )\r
{\r
  UINT32  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);\r
\r
  ReturnBuffer = (UINT32 *)Buffer;\r
\r
  while (Length != 0) {\r
    MmioWrite32 (StartAddress, *(Buffer++));\r
\r
    StartAddress += sizeof (UINT32);\r
    Length       -= sizeof (UINT32);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
\r
/**\r
  Copy data from system memory to MMIO region by using 64-bit access.\r
\r
  Copy data from system memory specified by Buffer to MMIO region specified\r
  by starting address StartAddress by using 64-bit access. The total number\r
  of byte to be copied is specified by Length. Buffer is returned.\r
\r
  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
\r
  If Length is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  If Buffer is not aligned on a 64-bit boundary, then ASSERT().\r
\r
  @param  StartAddress    The starting address for the MMIO region to be copied to.\r
  @param  Length          The size, in bytes, of Buffer.\r
  @param  Buffer          The pointer to a system memory buffer containing the data to write.\r
\r
  @return Buffer\r
\r
**/\r
UINT64 *\r
EFIAPI\r
MmioWriteBuffer64 (\r
  IN  UINTN         StartAddress,\r
  IN  UINTN         Length,\r
  IN  CONST UINT64  *Buffer\r
  )\r
{\r
  UINT64  *ReturnBuffer;\r
\r
  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);\r
\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));\r
  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN)Buffer));\r
\r
  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);\r
  ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);\r
\r
  ReturnBuffer = (UINT64 *)Buffer;\r
\r
  while (Length != 0) {\r
    MmioWrite64 (StartAddress, *(Buffer++));\r
\r
    StartAddress += sizeof (UINT64);\r
    Length       -= sizeof (UINT64);\r
  }\r
\r
  return ReturnBuffer;\r
}\r
Commit	Line	Data
11f43dfd	1	/** @file\r
11f43dfd	2	I/O Library MMIO Buffer Functions.\r
4ca0802e	3	The implementations are based on EFI_PEI_SERVICE->CpuIo interface.\r
11f43dfd	4	\r
9095d37b	5	Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
9344f092	6	SPDX-License-Identifier: BSD-2-Clause-Patent\r
11f43dfd	7	\r
	8	**/\r
	9	\r
11f43dfd	10	#include <PiPei.h>\r
c892d846	11	\r
11f43dfd	12	#include <Library/IoLib.h>\r
	13	#include <Library/DebugLib.h>\r
	14	#include <Library/BaseLib.h>\r
	15	#include <Library/PeiServicesTablePointerLib.h>\r
	16	\r
	17	/**\r
	18	Copy data from MMIO region to system memory by using 8-bit access.\r
	19	\r
9095d37b LG	20	Copy data from MMIO region specified by starting address StartAddress\r
9095d37b LG	21	to system memory specified by Buffer by using 8-bit access. The total\r
11f43dfd	22	number of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b LG	23	\r
9095d37b LG	24	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	25	If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
	26	\r
	27	\r
2fc59a00	28	@param StartAddress The starting address for the MMIO region to be copied from.\r
80f0c0c4	29	@param Length The size, in bytes, of Buffer.\r
2fc59a00	30	@param Buffer The pointer to a system memory buffer receiving the data read.\r
11f43dfd	31	\r
80f0c0c4	32	@return Buffer\r
11f43dfd	33	\r
	34	**/\r
	35	UINT8 *\r
	36	EFIAPI\r
	37	MmioReadBuffer8 (\r
2f88bd3a MK	38	IN UINTN StartAddress,\r
	39	IN UINTN Length,\r
	40	OUT UINT8 *Buffer\r
11f43dfd	41	)\r
11f43dfd	42	{\r
2f88bd3a	43	UINT8 *ReturnBuffer;\r
11f43dfd	44	\r
11f43dfd	45	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	46	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
9095d37b	47	\r
11f43dfd	48	ReturnBuffer = Buffer;\r
9095d37b	49	\r
42eedea9	50	while (Length-- != 0) {\r
11f43dfd	51	*(Buffer++) = MmioRead8 (StartAddress++);\r
	52	}\r
	53	\r
	54	return ReturnBuffer;\r
	55	}\r
	56	\r
	57	/**\r
	58	Copy data from MMIO region to system memory by using 16-bit access.\r
	59	\r
9095d37b LG	60	Copy data from MMIO region specified by starting address StartAddress\r
9095d37b LG	61	to system memory specified by Buffer by using 16-bit access. The total\r
11f43dfd	62	number of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	63	\r
11f43dfd	64	If StartAddress is not aligned on a 16-bit boundary, then ASSERT().\r
11f43dfd	65	\r
9095d37b	66	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	67	If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
	68	\r
	69	If Length is not aligned on a 16-bit boundary, then ASSERT().\r
	70	If Buffer is not aligned on a 16-bit boundary, then ASSERT().\r
	71	\r
2fc59a00	72	@param StartAddress The starting address for the MMIO region to be copied from.\r
80f0c0c4	73	@param Length The size, in bytes, of Buffer.\r
2fc59a00	74	@param Buffer The pointer to a system memory buffer receiving the data read.\r
11f43dfd	75	\r
80f0c0c4	76	@return Buffer\r
11f43dfd	77	\r
	78	**/\r
	79	UINT16 *\r
	80	EFIAPI\r
	81	MmioReadBuffer16 (\r
2f88bd3a MK	82	IN UINTN StartAddress,\r
	83	IN UINTN Length,\r
	84	OUT UINT16 *Buffer\r
11f43dfd	85	)\r
11f43dfd	86	{\r
2f88bd3a	87	UINT16 *ReturnBuffer;\r
11f43dfd	88	\r
11f43dfd	89	ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);\r
9095d37b	90	\r
11f43dfd	91	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	92	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	93	\r
11f43dfd	94	ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);\r
2f88bd3a	95	ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);\r
9095d37b	96	\r
11f43dfd	97	ReturnBuffer = Buffer;\r
9095d37b	98	\r
42eedea9	99	while (Length != 0) {\r
2f88bd3a	100	*(Buffer++) = MmioRead16 (StartAddress);\r
11f43dfd	101	StartAddress += sizeof (UINT16);\r
2f88bd3a	102	Length -= sizeof (UINT16);\r
11f43dfd	103	}\r
	104	\r
	105	return ReturnBuffer;\r
	106	}\r
	107	\r
	108	/**\r
	109	Copy data from MMIO region to system memory by using 32-bit access.\r
	110	\r
9095d37b LG	111	Copy data from MMIO region specified by starting address StartAddress\r
9095d37b LG	112	to system memory specified by Buffer by using 32-bit access. The total\r
11f43dfd	113	number of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	114	\r
11f43dfd	115	If StartAddress is not aligned on a 32-bit boundary, then ASSERT().\r
11f43dfd	116	\r
9095d37b	117	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	118	If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
	119	\r
	120	If Length is not aligned on a 32-bit boundary, then ASSERT().\r
	121	If Buffer is not aligned on a 32-bit boundary, then ASSERT().\r
	122	\r
2fc59a00	123	@param StartAddress The starting address for the MMIO region to be copied from.\r
80f0c0c4	124	@param Length The size, in bytes, of Buffer.\r
2fc59a00	125	@param Buffer The pointer to a system memory buffer receiving the data read.\r
11f43dfd	126	\r
80f0c0c4	127	@return Buffer\r
11f43dfd	128	\r
	129	**/\r
	130	UINT32 *\r
	131	EFIAPI\r
	132	MmioReadBuffer32 (\r
2f88bd3a MK	133	IN UINTN StartAddress,\r
	134	IN UINTN Length,\r
	135	OUT UINT32 *Buffer\r
11f43dfd	136	)\r
11f43dfd	137	{\r
2f88bd3a	138	UINT32 *ReturnBuffer;\r
11f43dfd	139	\r
11f43dfd	140	ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);\r
9095d37b	141	\r
11f43dfd	142	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	143	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	144	\r
11f43dfd	145	ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);\r
2f88bd3a	146	ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);\r
9095d37b	147	\r
11f43dfd	148	ReturnBuffer = Buffer;\r
9095d37b	149	\r
42eedea9	150	while (Length != 0) {\r
2f88bd3a	151	*(Buffer++) = MmioRead32 (StartAddress);\r
11f43dfd	152	StartAddress += sizeof (UINT32);\r
2f88bd3a	153	Length -= sizeof (UINT32);\r
11f43dfd	154	}\r
	155	\r
	156	return ReturnBuffer;\r
	157	}\r
	158	\r
	159	/**\r
	160	Copy data from MMIO region to system memory by using 64-bit access.\r
	161	\r
9095d37b LG	162	Copy data from MMIO region specified by starting address StartAddress\r
9095d37b LG	163	to system memory specified by Buffer by using 64-bit access. The total\r
11f43dfd	164	number of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	165	\r
11f43dfd	166	If StartAddress is not aligned on a 64-bit boundary, then ASSERT().\r
11f43dfd	167	\r
9095d37b	168	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	169	If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().\r
	170	\r
	171	If Length is not aligned on a 64-bit boundary, then ASSERT().\r
	172	If Buffer is not aligned on a 64-bit boundary, then ASSERT().\r
	173	\r
2fc59a00	174	@param StartAddress The starting address for the MMIO region to be copied from.\r
80f0c0c4	175	@param Length The size, in bytes, of Buffer.\r
2fc59a00	176	@param Buffer The pointer to a system memory buffer receiving the data read.\r
11f43dfd	177	\r
80f0c0c4	178	@return Buffer\r
11f43dfd	179	\r
	180	**/\r
	181	UINT64 *\r
	182	EFIAPI\r
	183	MmioReadBuffer64 (\r
2f88bd3a MK	184	IN UINTN StartAddress,\r
	185	IN UINTN Length,\r
	186	OUT UINT64 *Buffer\r
11f43dfd	187	)\r
11f43dfd	188	{\r
2f88bd3a	189	UINT64 *ReturnBuffer;\r
11f43dfd	190	\r
11f43dfd	191	ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);\r
9095d37b	192	\r
11f43dfd	193	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	194	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	195	\r
11f43dfd	196	ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);\r
2f88bd3a	197	ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);\r
9095d37b	198	\r
11f43dfd	199	ReturnBuffer = Buffer;\r
9095d37b	200	\r
42eedea9	201	while (Length != 0) {\r
2f88bd3a	202	*(Buffer++) = MmioRead64 (StartAddress);\r
11f43dfd	203	StartAddress += sizeof (UINT64);\r
2f88bd3a	204	Length -= sizeof (UINT64);\r
11f43dfd	205	}\r
	206	\r
	207	return ReturnBuffer;\r
	208	}\r
	209	\r
11f43dfd	210	/**\r
	211	Copy data from system memory to MMIO region by using 8-bit access.\r
	212	\r
9095d37b LG	213	Copy data from system memory specified by Buffer to MMIO region specified\r
9095d37b LG	214	by starting address StartAddress by using 8-bit access. The total number\r
11f43dfd	215	of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b LG	216	\r
9095d37b LG	217	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	218	If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
	219	\r
	220	\r
2fc59a00	221	@param StartAddress The starting address for the MMIO region to be copied to.\r
80f0c0c4	222	@param Length The size, in bytes, of Buffer.\r
2fc59a00	223	@param Buffer The pointer to a system memory buffer containing the data to write.\r
11f43dfd	224	\r
3222ffc0	225	@return Buffer\r
11f43dfd	226	\r
	227	**/\r
	228	UINT8 *\r
	229	EFIAPI\r
	230	MmioWriteBuffer8 (\r
2f88bd3a MK	231	IN UINTN StartAddress,\r
	232	IN UINTN Length,\r
	233	IN CONST UINT8 *Buffer\r
11f43dfd	234	)\r
11f43dfd	235	{\r
2f88bd3a	236	VOID *ReturnBuffer;\r
11f43dfd	237	\r
11f43dfd	238	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	239	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
9095d37b	240	\r
2f88bd3a	241	ReturnBuffer = (UINT8 *)Buffer;\r
9095d37b	242	\r
42eedea9	243	while (Length-- != 0) {\r
2f88bd3a	244	MmioWrite8 (StartAddress++, *(Buffer++));\r
11f43dfd	245	}\r
	246	\r
	247	return ReturnBuffer;\r
11f43dfd	248	}\r
	249	\r
	250	/**\r
	251	Copy data from system memory to MMIO region by using 16-bit access.\r
	252	\r
9095d37b LG	253	Copy data from system memory specified by Buffer to MMIO region specified\r
9095d37b LG	254	by starting address StartAddress by using 16-bit access. The total number\r
3222ffc0	255	of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	256	\r
11f43dfd	257	If StartAddress is not aligned on a 16-bit boundary, then ASSERT().\r
11f43dfd	258	\r
9095d37b	259	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	260	If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
	261	\r
	262	If Length is not aligned on a 16-bit boundary, then ASSERT().\r
	263	\r
	264	If Buffer is not aligned on a 16-bit boundary, then ASSERT().\r
	265	\r
2fc59a00	266	@param StartAddress The starting address for the MMIO region to be copied to.\r
80f0c0c4	267	@param Length The size, in bytes, of Buffer.\r
2fc59a00	268	@param Buffer The pointer to a system memory buffer containing the data to write.\r
11f43dfd	269	\r
3222ffc0	270	@return Buffer\r
11f43dfd	271	\r
	272	**/\r
	273	UINT16 *\r
	274	EFIAPI\r
	275	MmioWriteBuffer16 (\r
2f88bd3a MK	276	IN UINTN StartAddress,\r
	277	IN UINTN Length,\r
	278	IN CONST UINT16 *Buffer\r
11f43dfd	279	)\r
11f43dfd	280	{\r
2f88bd3a	281	UINT16 *ReturnBuffer;\r
11f43dfd	282	\r
11f43dfd	283	ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);\r
9095d37b	284	\r
11f43dfd	285	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	286	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	287	\r
11f43dfd	288	ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);\r
2f88bd3a	289	ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);\r
11f43dfd	290	\r
2f88bd3a	291	ReturnBuffer = (UINT16 *)Buffer;\r
9095d37b	292	\r
42eedea9	293	while (Length != 0) {\r
11f43dfd	294	MmioWrite16 (StartAddress, *(Buffer++));\r
9095d37b	295	\r
11f43dfd	296	StartAddress += sizeof (UINT16);\r
2f88bd3a	297	Length -= sizeof (UINT16);\r
11f43dfd	298	}\r
	299	\r
	300	return ReturnBuffer;\r
	301	}\r
	302	\r
11f43dfd	303	/**\r
	304	Copy data from system memory to MMIO region by using 32-bit access.\r
	305	\r
9095d37b LG	306	Copy data from system memory specified by Buffer to MMIO region specified\r
9095d37b LG	307	by starting address StartAddress by using 32-bit access. The total number\r
3222ffc0	308	of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	309	\r
11f43dfd	310	If StartAddress is not aligned on a 32-bit boundary, then ASSERT().\r
11f43dfd	311	\r
9095d37b	312	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	313	If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
	314	\r
	315	If Length is not aligned on a 32-bit boundary, then ASSERT().\r
	316	\r
	317	If Buffer is not aligned on a 32-bit boundary, then ASSERT().\r
	318	\r
2fc59a00	319	@param StartAddress The starting address for the MMIO region to be copied to.\r
80f0c0c4	320	@param Length The size, in bytes, of Buffer.\r
2fc59a00	321	@param Buffer The pointer to a system memory buffer containing the data to write.\r
11f43dfd	322	\r
3222ffc0	323	@return Buffer\r
11f43dfd	324	\r
	325	**/\r
	326	UINT32 *\r
	327	EFIAPI\r
	328	MmioWriteBuffer32 (\r
2f88bd3a MK	329	IN UINTN StartAddress,\r
	330	IN UINTN Length,\r
	331	IN CONST UINT32 *Buffer\r
11f43dfd	332	)\r
11f43dfd	333	{\r
2f88bd3a	334	UINT32 *ReturnBuffer;\r
11f43dfd	335	\r
11f43dfd	336	ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);\r
9095d37b	337	\r
11f43dfd	338	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	339	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	340	\r
11f43dfd	341	ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);\r
2f88bd3a	342	ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);\r
11f43dfd	343	\r
2f88bd3a	344	ReturnBuffer = (UINT32 *)Buffer;\r
9095d37b	345	\r
42eedea9	346	while (Length != 0) {\r
11f43dfd	347	MmioWrite32 (StartAddress, *(Buffer++));\r
9095d37b	348	\r
11f43dfd	349	StartAddress += sizeof (UINT32);\r
2f88bd3a	350	Length -= sizeof (UINT32);\r
11f43dfd	351	}\r
	352	\r
	353	return ReturnBuffer;\r
	354	}\r
	355	\r
	356	/**\r
	357	Copy data from system memory to MMIO region by using 64-bit access.\r
	358	\r
9095d37b LG	359	Copy data from system memory specified by Buffer to MMIO region specified\r
9095d37b LG	360	by starting address StartAddress by using 64-bit access. The total number\r
3222ffc0	361	of byte to be copied is specified by Length. Buffer is returned.\r
9095d37b	362	\r
11f43dfd	363	If StartAddress is not aligned on a 64-bit boundary, then ASSERT().\r
11f43dfd	364	\r
9095d37b	365	If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().\r
11f43dfd	366	If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().\r
	367	\r
	368	If Length is not aligned on a 64-bit boundary, then ASSERT().\r
	369	\r
	370	If Buffer is not aligned on a 64-bit boundary, then ASSERT().\r
	371	\r
2fc59a00	372	@param StartAddress The starting address for the MMIO region to be copied to.\r
80f0c0c4	373	@param Length The size, in bytes, of Buffer.\r
2fc59a00	374	@param Buffer The pointer to a system memory buffer containing the data to write.\r
11f43dfd	375	\r
3222ffc0	376	@return Buffer\r
11f43dfd	377	\r
	378	**/\r
	379	UINT64 *\r
	380	EFIAPI\r
	381	MmioWriteBuffer64 (\r
2f88bd3a MK	382	IN UINTN StartAddress,\r
	383	IN UINTN Length,\r
	384	IN CONST UINT64 *Buffer\r
11f43dfd	385	)\r
11f43dfd	386	{\r
2f88bd3a	387	UINT64 *ReturnBuffer;\r
11f43dfd	388	\r
11f43dfd	389	ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);\r
9095d37b	390	\r
11f43dfd	391	ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));\r
2f88bd3a	392	ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));\r
11f43dfd	393	\r
11f43dfd	394	ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);\r
2f88bd3a	395	ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);\r
11f43dfd	396	\r
2f88bd3a	397	ReturnBuffer = (UINT64 *)Buffer;\r
9095d37b	398	\r
42eedea9	399	while (Length != 0) {\r
11f43dfd	400	MmioWrite64 (StartAddress, *(Buffer++));\r
9095d37b	401	\r
11f43dfd	402	StartAddress += sizeof (UINT64);\r
2f88bd3a	403	Length -= sizeof (UINT64);\r
11f43dfd	404	}\r
	405	\r
	406	return ReturnBuffer;\r
	407	}\r