Home | History | Annotate | Download | only in DxeIoLibEsal
      1 /** @file
      2   I/O Library MMIO Buffer Functions.
      3 
      4   Copyright (c) 2006 - 2011, 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 **/
     14 
     15 #include "DxeIoLibEsalInternal.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    Starting address for the MMIO region to be copied from.
     29   @param  Length          Size in bytes of the copy.
     30   @param  Buffer          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   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
     71 
     72   @param  StartAddress    Starting address for the MMIO region to be copied from.
     73   @param  Length          Size in bytes of the copy.
     74   @param  Buffer          Pointer to a system memory buffer receiving the data read.
     75 
     76   @return Buffer
     77 
     78 **/
     79 UINT16 *
     80 EFIAPI
     81 MmioReadBuffer16 (
     82   IN  UINTN       StartAddress,
     83   IN  UINTN       Length,
     84   OUT UINT16      *Buffer
     85   )
     86 {
     87   UINT16    *ReturnBuffer;
     88 
     89   ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
     90 
     91   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
     92   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
     93 
     94   ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
     95   ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
     96 
     97   ReturnBuffer = Buffer;
     98 
     99   while (Length > 0) {
    100     *(Buffer++) = MmioRead16 (StartAddress);
    101     StartAddress += sizeof (UINT16);
    102     Length -= sizeof (UINT16);
    103   }
    104 
    105   return ReturnBuffer;
    106 }
    107 
    108 /**
    109   Copy data from MMIO region to system memory by using 32-bit access.
    110 
    111   Copy data from MMIO region specified by starting address StartAddress
    112   to system memory specified by Buffer by using 32-bit access. The total
    113   number of byte to be copied is specified by Length. Buffer is returned.
    114 
    115   If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
    116 
    117   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    118   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
    119 
    120   If Length is not aligned on a 32-bit boundary, then ASSERT().
    121   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
    122 
    123   @param  StartAddress    Starting address for the MMIO region to be copied from.
    124   @param  Length          Size in bytes of the copy.
    125   @param  Buffer          Pointer to a system memory buffer receiving the data read.
    126 
    127   @return Buffer
    128 
    129 **/
    130 UINT32 *
    131 EFIAPI
    132 MmioReadBuffer32 (
    133   IN  UINTN       StartAddress,
    134   IN  UINTN       Length,
    135   OUT UINT32      *Buffer
    136   )
    137 {
    138   UINT32    *ReturnBuffer;
    139 
    140   ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
    141 
    142   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
    143   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
    144 
    145   ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
    146   ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
    147 
    148   ReturnBuffer = Buffer;
    149 
    150   while (Length > 0) {
    151     *(Buffer++) = MmioRead32 (StartAddress);
    152     StartAddress += sizeof (UINT32);
    153     Length -= sizeof (UINT32);
    154   }
    155 
    156   return ReturnBuffer;
    157 }
    158 
    159 /**
    160   Copy data from MMIO region to system memory by using 64-bit access.
    161 
    162   Copy data from MMIO region specified by starting address StartAddress
    163   to system memory specified by Buffer by using 64-bit access. The total
    164   number of byte to be copied is specified by Length. Buffer is returned.
    165 
    166   If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
    167 
    168   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    169   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
    170 
    171   If Length is not aligned on a 64-bit boundary, then ASSERT().
    172   If Buffer is not aligned on a 64-bit boundary, then ASSERT().
    173 
    174   @param  StartAddress    Starting address for the MMIO region to be copied from.
    175   @param  Length          Size in bytes of the copy.
    176   @param  Buffer          Pointer to a system memory buffer receiving the data read.
    177 
    178   @return Buffer
    179 
    180 **/
    181 UINT64 *
    182 EFIAPI
    183 MmioReadBuffer64 (
    184   IN  UINTN       StartAddress,
    185   IN  UINTN       Length,
    186   OUT UINT64      *Buffer
    187   )
    188 {
    189   UINT64    *ReturnBuffer;
    190 
    191   ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
    192 
    193   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
    194   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
    195 
    196   ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
    197   ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
    198 
    199   ReturnBuffer = Buffer;
    200 
    201   while (Length > 0) {
    202     *(Buffer++) = MmioRead64 (StartAddress);
    203     StartAddress += sizeof (UINT64);
    204     Length -= sizeof (UINT64);
    205   }
    206 
    207   return ReturnBuffer;
    208 }
    209 
    210 
    211 /**
    212   Copy data from system memory to MMIO region by using 8-bit access.
    213 
    214   Copy data from system memory specified by Buffer to MMIO region specified
    215   by starting address StartAddress by using 8-bit access. The total number
    216   of byte to be copied is specified by Length. Buffer is returned.
    217 
    218   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    219   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
    220 
    221 
    222   @param  StartAddress    Starting address for the MMIO region to be copied to.
    223   @param  Length     Size in bytes of the copy.
    224   @param  Buffer          Pointer to a system memory buffer containing the data to write.
    225 
    226   @return Buffer
    227 
    228 **/
    229 UINT8 *
    230 EFIAPI
    231 MmioWriteBuffer8 (
    232   IN  UINTN         StartAddress,
    233   IN  UINTN         Length,
    234   IN  CONST UINT8   *Buffer
    235   )
    236 {
    237   VOID* ReturnBuffer;
    238 
    239   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
    240   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
    241 
    242   ReturnBuffer = (UINT8 *) Buffer;
    243 
    244   while (Length-- > 0) {
    245      MmioWrite8 (StartAddress++, *(Buffer++));
    246   }
    247 
    248   return ReturnBuffer;
    249 
    250 }
    251 
    252 /**
    253   Copy data from system memory to MMIO region by using 16-bit access.
    254 
    255   Copy data from system memory specified by Buffer to MMIO region specified
    256   by starting address StartAddress by using 16-bit access. The total number
    257   of byte to be copied is specified by Length. Buffer is returned.
    258 
    259   If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
    260 
    261   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    262   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
    263 
    264   If Length is not aligned on a 16-bit boundary, then ASSERT().
    265 
    266   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
    267 
    268   @param  StartAddress    Starting address for the MMIO region to be copied to.
    269   @param  Length     Size in bytes of the copy.
    270   @param  Buffer          Pointer to a system memory buffer containing the data to write.
    271 
    272   @return Buffer
    273 
    274 **/
    275 UINT16 *
    276 EFIAPI
    277 MmioWriteBuffer16 (
    278   IN  UINTN        StartAddress,
    279   IN  UINTN        Length,
    280   IN  CONST UINT16 *Buffer
    281   )
    282 {
    283   UINT16    *ReturnBuffer;
    284 
    285   ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
    286 
    287   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
    288   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
    289 
    290   ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
    291   ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
    292 
    293   ReturnBuffer = (UINT16 *) Buffer;
    294 
    295   while (Length > 0) {
    296     MmioWrite16 (StartAddress, *(Buffer++));
    297 
    298     StartAddress += sizeof (UINT16);
    299     Length -= sizeof (UINT16);
    300   }
    301 
    302   return ReturnBuffer;
    303 }
    304 
    305 
    306 /**
    307   Copy data from system memory to MMIO region by using 32-bit access.
    308 
    309   Copy data from system memory specified by Buffer to MMIO region specified
    310   by starting address StartAddress by using 32-bit access. The total number
    311   of byte to be copied is specified by Length. Buffer is returned.
    312 
    313   If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
    314 
    315   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    316   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
    317 
    318   If Length is not aligned on a 32-bit boundary, then ASSERT().
    319 
    320   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
    321 
    322   @param  StartAddress    Starting address for the MMIO region to be copied to.
    323   @param  Length     Size in bytes of the copy.
    324   @param  Buffer          Pointer to a system memory buffer containing the data to write.
    325 
    326   @return Buffer
    327 
    328 **/
    329 UINT32 *
    330 EFIAPI
    331 MmioWriteBuffer32 (
    332   IN  UINTN        StartAddress,
    333   IN  UINTN        Length,
    334   IN  CONST UINT32 *Buffer
    335   )
    336 {
    337   UINT32    *ReturnBuffer;
    338 
    339   ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
    340 
    341   ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
    342   ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
    343 
    344   ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
    345   ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
    346 
    347   ReturnBuffer = (UINT32 *) Buffer;
    348 
    349   while (Length > 0) {
    350     MmioWrite32 (StartAddress, *(Buffer++));
    351 
    352     StartAddress += sizeof (UINT32);
    353     Length -= sizeof (UINT32);
    354   }
    355 
    356   return ReturnBuffer;
    357 }
    358 
    359 /**
    360   Copy data from system memory to MMIO region by using 64-bit access.
    361 
    362   Copy data from system memory specified by Buffer to MMIO region specified
    363   by starting address StartAddress by using 64-bit access. The total number
    364   of byte to be copied is specified by Length. Buffer is returned.
    365 
    366   If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
    367 
    368   If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
    369   If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
    370 
    371   If Length is not aligned on a 64-bit boundary, then ASSERT().
    372 
    373   If Buffer is not aligned on a 64-bit boundary, then ASSERT().
    374 
    375   @param  StartAddress    Starting address for the MMIO region to be copied to.
    376   @param  Length     Size in bytes of the copy.
    377   @param  Buffer          Pointer to a system memory buffer containing the 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 
    412