MdePkg/Library/PeiIoLibCpuIo/IoLibMmioBuffer.c

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