MdePkg/Library/SmmIoLibSmmCpuIo2/IoLibMmioBuffer.c

   1 /** @file
   2   I/O Library MMIO Buffer Functions.
   3
   4   Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "SmmCpuIoLibInternal.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 /**
 208   Copy data from system memory to MMIO region by using 8-bit access.
 209
 210   Copy data from system memory specified by Buffer to MMIO region specified
 211   by starting address StartAddress by using 8-bit access. The total number
 212   of byte to be copied is specified by Length. Buffer is returned.
 213
 214   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 215   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
 216
 217
 218   @param  StartAddress    The starting address for the MMIO region to be copied to.
 219   @param  Length          The size in bytes of the copy.
 220   @param  Buffer          The pointer to a system memory buffer containing the
 221                           data to write.
 222
 223   @return Buffer
 224
 225 **/
 226 UINT8 *
 227 EFIAPI
 228 MmioWriteBuffer8 (
 229   IN  UINTN         StartAddress,
 230   IN  UINTN         Length,
 231   IN  CONST UINT8   *Buffer
 232   )
 233 {
 234   VOID* ReturnBuffer;
 235
 236   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
 237   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
 238
 239   ReturnBuffer = (UINT8 *) Buffer;
 240
 241   while (Length-- > 0) {
 242      MmioWrite8 (StartAddress++, *(Buffer++));
 243   }
 244
 245   return ReturnBuffer;
 246
 247 }
 248
 249 /**
 250   Copy data from system memory to MMIO region by using 16-bit access.
 251
 252   Copy data from system memory specified by Buffer to MMIO region specified
 253   by starting address StartAddress by using 16-bit access. The total number
 254   of byte to be copied is specified by Length. Buffer is returned.
 255
 256   If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
 257
 258   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 259   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
 260
 261   If Length is not aligned on a 16-bit boundary, then ASSERT().
 262
 263   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
 264
 265   @param  StartAddress    The starting address for the MMIO region to be copied to.
 266   @param  Length          The size in bytes of the copy.
 267   @param  Buffer          The pointer to a system memory buffer containing the
 268                           data to write.
 269
 270   @return Buffer
 271
 272 **/
 273 UINT16 *
 274 EFIAPI
 275 MmioWriteBuffer16 (
 276   IN  UINTN        StartAddress,
 277   IN  UINTN        Length,
 278   IN  CONST UINT16 *Buffer
 279   )
 280 {
 281   UINT16    *ReturnBuffer;
 282
 283   ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
 284
 285   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
 286   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
 287
 288   ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
 289   ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
 290
 291   ReturnBuffer = (UINT16 *) Buffer;
 292
 293   while (Length > 0) {
 294     MmioWrite16 (StartAddress, *(Buffer++));
 295
 296     StartAddress += sizeof (UINT16);
 297     Length -= sizeof (UINT16);
 298   }
 299
 300   return ReturnBuffer;
 301 }
 302
 303
 304 /**
 305   Copy data from system memory to MMIO region by using 32-bit access.
 306
 307   Copy data from system memory specified by Buffer to MMIO region specified
 308   by starting address StartAddress by using 32-bit access. The total number
 309   of byte to be copied is specified by Length. Buffer is returned.
 310
 311   If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
 312
 313   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 314   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
 315
 316   If Length is not aligned on a 32-bit boundary, then ASSERT().
 317
 318   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
 319
 320   @param  StartAddress    The starting address for the MMIO region to be copied to.
 321   @param  Length          The size in bytes of the copy.
 322   @param  Buffer          The pointer to a system memory buffer containing the
 323                           data to write.
 324
 325   @return Buffer
 326
 327 **/
 328 UINT32 *
 329 EFIAPI
 330 MmioWriteBuffer32 (
 331   IN  UINTN        StartAddress,
 332   IN  UINTN        Length,
 333   IN  CONST UINT32 *Buffer
 334   )
 335 {
 336   UINT32    *ReturnBuffer;
 337
 338   ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
 339
 340   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
 341   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
 342
 343   ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
 344   ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
 345
 346   ReturnBuffer = (UINT32 *) Buffer;
 347
 348   while (Length > 0) {
 349     MmioWrite32 (StartAddress, *(Buffer++));
 350
 351     StartAddress += sizeof (UINT32);
 352     Length -= sizeof (UINT32);
 353   }
 354
 355   return ReturnBuffer;
 356 }
 357
 358 /**
 359   Copy data from system memory to MMIO region by using 64-bit access.
 360
 361   Copy data from system memory specified by Buffer to MMIO region specified
 362   by starting address StartAddress by using 64-bit access. The total number
 363   of byte to be copied is specified by Length. Buffer is returned.
 364
 365   If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
 366
 367   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 368   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
 369
 370   If Length is not aligned on a 64-bit boundary, then ASSERT().
 371
 372   If Buffer is not aligned on a 64-bit boundary, then ASSERT().
 373
 374   @param  StartAddress    The starting address for the MMIO region to be copied to.
 375   @param  Length          The size in bytes of the copy.
 376   @param  Buffer          The pointer to a system memory buffer containing the
 377                           data to write.
 378
 379   @return Buffer
 380
 381 **/
 382 UINT64 *
 383 EFIAPI
 384 MmioWriteBuffer64 (
 385   IN  UINTN        StartAddress,
 386   IN  UINTN        Length,
 387   IN  CONST UINT64 *Buffer
 388   )
 389 {
 390   UINT64    *ReturnBuffer;
 391
 392   ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
 393
 394   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
 395   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
 396
 397   ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
 398   ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
 399
 400   ReturnBuffer = (UINT64 *) Buffer;
 401
 402   while (Length > 0) {
 403     MmioWrite64 (StartAddress, *(Buffer++));
 404
 405     StartAddress += sizeof (UINT64);
 406     Length -= sizeof (UINT64);
 407   }
 408
 409   return ReturnBuffer;
 410 }
 411