MdePkg/Library/DxeIoLibCpuIo2/IoLibMmioBuffer.c

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