IntelFrameworkPkg/Library/DxeIoLibCpuIo/IoLibMmioBuffer.c

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