Home | History | Annotate | Download | only in DxeIoLibCpuIo
      1 /** @file
      2   I/O Library MMIO Buffer Functions.
      3 
      4   Copyright (c) 2007, 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 
    417