Home | History | Annotate | Download | only in BaseIoLibIntrinsic
      1 /** @file
      2   I/O Library for ARM.
      3 
      4   Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
      5   Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
      6   This program and the accompanying materials
      7   are licensed and made available under the terms and conditions of the BSD License
      8   which accompanies this distribution.  The full text of the license may be found at
      9   http://opensource.org/licenses/bsd-license.php.
     10 
     11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     13 
     14 **/
     15 
     16 
     17 //
     18 // Include common header file for this module.
     19 //
     20 #include "BaseIoLibIntrinsicInternal.h"
     21 
     22 /**
     23   Reads an 8-bit I/O port.
     24 
     25   Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
     26   This function must guarantee that all I/O read and write operations are
     27   serialized.
     28 
     29   If 8-bit I/O port operations are not supported, then ASSERT().
     30 
     31   @param  Port  The I/O port to read.
     32 
     33   @return The value read.
     34 
     35 **/
     36 UINT8
     37 EFIAPI
     38 IoRead8 (
     39   IN      UINTN                     Port
     40   )
     41 {
     42   ASSERT (FALSE);
     43   return 0;
     44 }
     45 
     46 /**
     47   Writes an 8-bit I/O port.
     48 
     49   Writes the 8-bit I/O port specified by Port with the value specified by Value
     50   and returns Value. This function must guarantee that all I/O read and write
     51   operations are serialized.
     52 
     53   If 8-bit I/O port operations are not supported, then ASSERT().
     54 
     55   @param  Port  The I/O port to write.
     56   @param  Value The value to write to the I/O port.
     57 
     58   @return The value written the I/O port.
     59 
     60 **/
     61 UINT8
     62 EFIAPI
     63 IoWrite8 (
     64   IN      UINTN                     Port,
     65   IN      UINT8                     Value
     66   )
     67 {
     68   ASSERT (FALSE);
     69   return Value;
     70 }
     71 
     72 /**
     73   Reads a 16-bit I/O port.
     74 
     75   Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
     76   This function must guarantee that all I/O read and write operations are
     77   serialized.
     78 
     79   If 16-bit I/O port operations are not supported, then ASSERT().
     80 
     81   @param  Port  The I/O port to read.
     82 
     83   @return The value read.
     84 
     85 **/
     86 UINT16
     87 EFIAPI
     88 IoRead16 (
     89   IN      UINTN                     Port
     90   )
     91 {
     92   ASSERT (FALSE);
     93   return 0;
     94 }
     95 
     96 /**
     97   Writes a 16-bit I/O port.
     98 
     99   Writes the 16-bit I/O port specified by Port with the value specified by Value
    100   and returns Value. This function must guarantee that all I/O read and write
    101   operations are serialized.
    102 
    103   If 16-bit I/O port operations are not supported, then ASSERT().
    104 
    105   @param  Port  The I/O port to write.
    106   @param  Value The value to write to the I/O port.
    107 
    108   @return The value written the I/O port.
    109 
    110 **/
    111 UINT16
    112 EFIAPI
    113 IoWrite16 (
    114   IN      UINTN                     Port,
    115   IN      UINT16                    Value
    116   )
    117 {
    118   ASSERT (FALSE);
    119   return Value;
    120 }
    121 
    122 /**
    123   Reads a 32-bit I/O port.
    124 
    125   Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
    126   This function must guarantee that all I/O read and write operations are
    127   serialized.
    128 
    129   If 32-bit I/O port operations are not supported, then ASSERT().
    130 
    131   @param  Port  The I/O port to read.
    132 
    133   @return The value read.
    134 
    135 **/
    136 UINT32
    137 EFIAPI
    138 IoRead32 (
    139   IN      UINTN                     Port
    140   )
    141 {
    142   ASSERT (FALSE);
    143   return 0;
    144 }
    145 
    146 /**
    147   Writes a 32-bit I/O port.
    148 
    149   Writes the 32-bit I/O port specified by Port with the value specified by Value
    150   and returns Value. This function must guarantee that all I/O read and write
    151   operations are serialized.
    152 
    153   If 32-bit I/O port operations are not supported, then ASSERT().
    154 
    155   @param  Port  The I/O port to write.
    156   @param  Value The value to write to the I/O port.
    157 
    158   @return The value written the I/O port.
    159 
    160 **/
    161 UINT32
    162 EFIAPI
    163 IoWrite32 (
    164   IN      UINTN                     Port,
    165   IN      UINT32                    Value
    166   )
    167 {
    168   ASSERT (FALSE);
    169   return Value;
    170 }
    171 
    172 /**
    173   Reads a 64-bit I/O port.
    174 
    175   Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
    176   This function must guarantee that all I/O read and write operations are
    177   serialized.
    178 
    179   If 64-bit I/O port operations are not supported, then ASSERT().
    180   If Port is not aligned on a 64-bit boundary, then ASSERT().
    181 
    182   @param  Port  The I/O port to read.
    183 
    184   @return The value read.
    185 
    186 **/
    187 UINT64
    188 EFIAPI
    189 IoRead64 (
    190   IN      UINTN                     Port
    191   )
    192 {
    193   ASSERT (FALSE);
    194   return 0;
    195 }
    196 
    197 /**
    198   Writes a 64-bit I/O port.
    199 
    200   Writes the 64-bit I/O port specified by Port with the value specified by Value
    201   and returns Value. This function must guarantee that all I/O read and write
    202   operations are serialized.
    203 
    204   If 64-bit I/O port operations are not supported, then ASSERT().
    205   If Port is not aligned on a 64-bit boundary, then ASSERT().
    206 
    207   @param  Port  The I/O port to write.
    208   @param  Value The value to write to the I/O port.
    209 
    210   @return The value written to the I/O port.
    211 
    212 **/
    213 UINT64
    214 EFIAPI
    215 IoWrite64 (
    216   IN      UINTN                     Port,
    217   IN      UINT64                    Value
    218   )
    219 {
    220   ASSERT (FALSE);
    221   return 0;
    222 }
    223 
    224 
    225 /**
    226   Reads an 8-bit MMIO register.
    227 
    228   Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
    229   returned. This function must guarantee that all MMIO read and write
    230   operations are serialized.
    231 
    232   If 8-bit MMIO register operations are not supported, then ASSERT().
    233 
    234   @param  Address The MMIO register to read.
    235 
    236   @return The value read.
    237 
    238 **/
    239 UINT8
    240 EFIAPI
    241 MmioRead8 (
    242   IN      UINTN                     Address
    243   )
    244 {
    245   UINT8                             Value;
    246 
    247   Value = *(volatile UINT8*)Address;
    248   return Value;
    249 }
    250 
    251 /**
    252   Writes an 8-bit MMIO register.
    253 
    254   Writes the 8-bit MMIO register specified by Address with the value specified
    255   by Value and returns Value. This function must guarantee that all MMIO read
    256   and write operations are serialized.
    257 
    258   If 8-bit MMIO register operations are not supported, then ASSERT().
    259 
    260   @param  Address The MMIO register to write.
    261   @param  Value   The value to write to the MMIO register.
    262 
    263 **/
    264 UINT8
    265 EFIAPI
    266 MmioWrite8 (
    267   IN      UINTN                     Address,
    268   IN      UINT8                     Value
    269   )
    270 {
    271   *(volatile UINT8*)Address = Value;
    272   return Value;
    273 }
    274 
    275 /**
    276   Reads a 16-bit MMIO register.
    277 
    278   Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
    279   returned. This function must guarantee that all MMIO read and write
    280   operations are serialized.
    281 
    282   If 16-bit MMIO register operations are not supported, then ASSERT().
    283 
    284   @param  Address The MMIO register to read.
    285 
    286   @return The value read.
    287 
    288 **/
    289 UINT16
    290 EFIAPI
    291 MmioRead16 (
    292   IN      UINTN                     Address
    293   )
    294 {
    295   UINT16                            Value;
    296 
    297   ASSERT ((Address & 1) == 0);
    298   Value = *(volatile UINT16*)Address;
    299   return Value;
    300 }
    301 
    302 /**
    303   Writes a 16-bit MMIO register.
    304 
    305   Writes the 16-bit MMIO register specified by Address with the value specified
    306   by Value and returns Value. This function must guarantee that all MMIO read
    307   and write operations are serialized.
    308 
    309   If 16-bit MMIO register operations are not supported, then ASSERT().
    310 
    311   @param  Address The MMIO register to write.
    312   @param  Value   The value to write to the MMIO register.
    313 
    314 **/
    315 UINT16
    316 EFIAPI
    317 MmioWrite16 (
    318   IN      UINTN                     Address,
    319   IN      UINT16                    Value
    320   )
    321 {
    322   ASSERT ((Address & 1) == 0);
    323   *(volatile UINT16*)Address = Value;
    324   return Value;
    325 }
    326 
    327 /**
    328   Reads a 32-bit MMIO register.
    329 
    330   Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
    331   returned. This function must guarantee that all MMIO read and write
    332   operations are serialized.
    333 
    334   If 32-bit MMIO register operations are not supported, then ASSERT().
    335 
    336   @param  Address The MMIO register to read.
    337 
    338   @return The value read.
    339 
    340 **/
    341 UINT32
    342 EFIAPI
    343 MmioRead32 (
    344   IN      UINTN                     Address
    345   )
    346 {
    347   UINT32                            Value;
    348 
    349   ASSERT ((Address & 3) == 0);
    350   Value = *(volatile UINT32*)Address;
    351   return Value;
    352 }
    353 
    354 /**
    355   Writes a 32-bit MMIO register.
    356 
    357   Writes the 32-bit MMIO register specified by Address with the value specified
    358   by Value and returns Value. This function must guarantee that all MMIO read
    359   and write operations are serialized.
    360 
    361   If 32-bit MMIO register operations are not supported, then ASSERT().
    362 
    363   @param  Address The MMIO register to write.
    364   @param  Value   The value to write to the MMIO register.
    365 
    366 **/
    367 UINT32
    368 EFIAPI
    369 MmioWrite32 (
    370   IN      UINTN                     Address,
    371   IN      UINT32                    Value
    372   )
    373 {
    374   ASSERT ((Address & 3) == 0);
    375   *(volatile UINT32*)Address = Value;
    376   return Value;
    377 }
    378 
    379 /**
    380   Reads a 64-bit MMIO register.
    381 
    382   Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
    383   returned. This function must guarantee that all MMIO read and write
    384   operations are serialized.
    385 
    386   If 64-bit MMIO register operations are not supported, then ASSERT().
    387 
    388   @param  Address The MMIO register to read.
    389 
    390   @return The value read.
    391 
    392 **/
    393 UINT64
    394 EFIAPI
    395 MmioRead64 (
    396   IN      UINTN                     Address
    397   )
    398 {
    399   UINT64                            Value;
    400 
    401   ASSERT ((Address & 7) == 0);
    402   Value = *(volatile UINT64*)Address;
    403   return Value;
    404 }
    405 
    406 /**
    407   Writes a 64-bit MMIO register.
    408 
    409   Writes the 64-bit MMIO register specified by Address with the value specified
    410   by Value and returns Value. This function must guarantee that all MMIO read
    411   and write operations are serialized.
    412 
    413   If 64-bit MMIO register operations are not supported, then ASSERT().
    414 
    415   @param  Address The MMIO register to write.
    416   @param  Value   The value to write to the MMIO register.
    417 
    418 **/
    419 UINT64
    420 EFIAPI
    421 MmioWrite64 (
    422   IN      UINTN                     Address,
    423   IN      UINT64                    Value
    424   )
    425 {
    426   ASSERT ((Address & 7) == 0);
    427   *(volatile UINT64*)Address = Value;
    428   return Value;
    429 }
    430 
    431