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