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

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