IntelFrameworkPkg/Library/DxeIoLibCpuIo/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 // Include common header file for this module.
  17 //
  18 #include "CommonHeader.h"
  19
  20 #include "DxeCpuIoLibInternal.h"
  21
  22 /**
  23   Copy data from MMIO region to system memory by using 8-bit access.
  24
  25   Copy data from MMIO region specified by starting address StartAddress
  26   to system memory specified by Buffer by using 8-bit access. The total
  27   number of byte to be copied is specified by Length. Buffer is returned.
  28
  29   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
  30   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
  31
  32
  33   @param  StartAddress    Starting address for the MMIO region to be copied from.
  34   @param  Length          Size in bytes of the copy.
  35   @param  Buffer          Pointer to a system memory buffer receiving the data read.
  36
  37   @return Buffer
  38
  39 **/
  40 UINT8 *
  41 EFIAPI
  42 MmioReadBuffer8 (
  43   IN  UINTN       StartAddress,
  44   IN  UINTN       Length,
  45   OUT UINT8       *Buffer
  46   )
  47 {
  48   UINT8   *ReturnBuffer;
  49
  50   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
  51   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
  52
  53   ReturnBuffer = Buffer;
  54
  55   while (Length--) {
  56     *(Buffer++) = MmioRead8 (StartAddress++);
  57   }
  58
  59   return ReturnBuffer;
  60 }
  61
  62 /**
  63   Copy data from MMIO region to system memory by using 16-bit access.
  64
  65   Copy data from MMIO region specified by starting address StartAddress
  66   to system memory specified by Buffer by using 16-bit access. The total
  67   number of byte to be copied is specified by Length. Buffer is returned.
  68
  69   If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
  70
  71   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
  72   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
  73
  74   If Length is not aligned on a 16-bit boundary, then ASSERT().
  75   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
  76
  77   @param  StartAddress    Starting address for the MMIO region to be copied from.
  78   @param  Length          Size in bytes of the copy.
  79   @param  Buffer          Pointer to a system memory buffer receiving the data read.
  80
  81   @return Buffer
  82
  83 **/
  84 UINT16 *
  85 EFIAPI
  86 MmioReadBuffer16 (
  87   IN  UINTN       StartAddress,
  88   IN  UINTN       Length,
  89   OUT UINT16      *Buffer
  90   )
  91 {
  92   UINT16    *ReturnBuffer;
  93
  94   ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
  95
  96   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
  97   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
  98
  99   ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
 100   ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
 101
 102   ReturnBuffer = Buffer;
 103
 104   while (Length) {
 105     *(Buffer++) = MmioRead16 (StartAddress);
 106     StartAddress += sizeof (UINT16);
 107     Length -= sizeof (UINT16);
 108   }
 109
 110   return ReturnBuffer;
 111 }
 112
 113 /**
 114   Copy data from MMIO region to system memory by using 32-bit access.
 115
 116   Copy data from MMIO region specified by starting address StartAddress
 117   to system memory specified by Buffer by using 32-bit access. The total
 118   number of byte to be copied is specified by Length. Buffer is returned.
 119
 120   If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
 121
 122   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 123   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 124
 125   If Length is not aligned on a 32-bit boundary, then ASSERT().
 126   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
 127
 128   @param  StartAddress    Starting address for the MMIO region to be copied from.
 129   @param  Length          Size in bytes of the copy.
 130   @param  Buffer          Pointer to a system memory buffer receiving the data read.
 131
 132   @return Buffer
 133
 134 **/
 135 UINT32 *
 136 EFIAPI
 137 MmioReadBuffer32 (
 138   IN  UINTN       StartAddress,
 139   IN  UINTN       Length,
 140   OUT UINT32      *Buffer
 141   )
 142 {
 143   UINT32    *ReturnBuffer;
 144
 145   ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
 146
 147   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
 148   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
 149
 150   ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
 151   ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
 152
 153   ReturnBuffer = Buffer;
 154
 155   while (Length) {
 156     *(Buffer++) = MmioRead32 (StartAddress);
 157     StartAddress += sizeof (UINT32);
 158     Length -= sizeof (UINT32);
 159   }
 160
 161   return ReturnBuffer;
 162 }
 163
 164 /**
 165   Copy data from MMIO region to system memory by using 64-bit access.
 166
 167   Copy data from MMIO region specified by starting address StartAddress
 168   to system memory specified by Buffer by using 64-bit access. The total
 169   number of byte to be copied is specified by Length. Buffer is returned.
 170
 171   If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
 172
 173   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
 174   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 175
 176   If Length is not aligned on a 64-bit boundary, then ASSERT().
 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) {
 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 Size in bytes of the copy.
 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--) {
 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. Length 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 Size in bytes of the copy.
 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) {
 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. Length 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 Size in bytes of the copy.
 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) {
 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. Length 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 Size in bytes of the copy.
 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) {
 408     MmioWrite64 (StartAddress, *(Buffer++));
 409
 410     StartAddress += sizeof (UINT64);
 411     Length -= sizeof (UINT64);
 412   }
 413
 414   return ReturnBuffer;
 415 }
 416