Home | History | Annotate | Download | only in SmmIoLibSmmCpuIo2
      1 /** @file
      2   I/O Library.
      3   The implementation of I/O operation for this library instance
      4   are based on EFI_CPU_IO_PROTOCOL.
      5 
      6   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
      7   This program and the accompanying materials
      8   are licensed and made available under the terms and conditions of the BSD License
      9   which accompanies this distribution.  The full text of the license may be found at
     10   http://opensource.org/licenses/bsd-license.php.
     11 
     12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     14 
     15 **/
     16 
     17 #include "SmmCpuIoLibInternal.h"
     18 
     19 /**
     20   Reads registers in the EFI CPU I/O space.
     21 
     22   Reads the I/O port specified by Port with registers width specified by Width.
     23   The read value is returned. If such operations are not supported, then ASSERT().
     24   This function must guarantee that all I/O read and write operations are serialized.
     25 
     26   @param  Port          The base address of the I/O operation.
     27                         The caller is responsible for aligning the Address if required.
     28   @param  Width         The width of the I/O operation.
     29 
     30   @return Data read from registers in the EFI CPU I/O space.
     31 
     32 **/
     33 UINT64
     34 EFIAPI
     35 IoReadWorker (
     36   IN      UINTN                     Port,
     37   IN      EFI_SMM_IO_WIDTH          Width
     38   )
     39 {
     40   EFI_STATUS                        Status;
     41   UINT64                            Data;
     42 
     43   Status = gSmst->SmmIo.Io.Read (&gSmst->SmmIo, Width, Port, 1, &Data);
     44   ASSERT_EFI_ERROR (Status);
     45 
     46   return Data;
     47 }
     48 
     49 /**
     50   Writes registers in the EFI CPU I/O space.
     51 
     52   Writes the I/O port specified by Port with registers width and value specified by Width
     53   and Data respectively.  Data is returned. If such operations are not supported, then ASSERT().
     54   This function must guarantee that all I/O read and write operations are serialized.
     55 
     56   @param  Port          The base address of the I/O operation.
     57                         The caller is responsible for aligning the Address if required.
     58   @param  Width         The width of the I/O operation.
     59   @param  Data          The value to write to the I/O port.
     60 
     61   @return The parameter of Data.
     62 
     63 **/
     64 UINT64
     65 EFIAPI
     66 IoWriteWorker (
     67   IN      UINTN                     Port,
     68   IN      EFI_SMM_IO_WIDTH          Width,
     69   IN      UINT64                    Data
     70   )
     71 {
     72   EFI_STATUS                        Status;
     73 
     74   Status = gSmst->SmmIo.Io.Write (&gSmst->SmmIo, Width, Port, 1, &Data);
     75   ASSERT_EFI_ERROR (Status);
     76 
     77   return Data;
     78 }
     79 
     80 /**
     81   Reads memory-mapped registers in the EFI system memory space.
     82 
     83   Reads the MMIO registers specified by Address with registers width specified by Width.
     84   The read value is returned. If such operations are not supported, then ASSERT().
     85   This function must guarantee that all MMIO read and write operations are serialized.
     86 
     87   @param  Address       The MMIO register to read.
     88                         The caller is responsible for aligning the Address if required.
     89   @param  Width         The width of the I/O operation.
     90 
     91   @return Data read from registers in the EFI system memory space.
     92 
     93 **/
     94 UINT64
     95 EFIAPI
     96 MmioReadWorker (
     97   IN      UINTN                     Address,
     98   IN      EFI_SMM_IO_WIDTH          Width
     99   )
    100 {
    101   EFI_STATUS                        Status;
    102   UINT64                            Data;
    103 
    104   Status = gSmst->SmmIo.Mem.Read (&gSmst->SmmIo, Width, Address, 1, &Data);
    105   ASSERT_EFI_ERROR (Status);
    106 
    107   return Data;
    108 }
    109 
    110 /**
    111   Writes memory-mapped registers in the EFI system memory space.
    112 
    113   Writes the MMIO registers specified by Address with registers width and value specified by Width
    114   and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
    115   This function must guarantee that all MMIO read and write operations are serialized.
    116 
    117   @param  Address       The MMIO register to read.
    118                         The caller is responsible for aligning the Address if required.
    119   @param  Width         The width of the I/O operation.
    120   @param  Data          The value to write to the I/O port.
    121 
    122   @return Data read from registers in the EFI system memory space.
    123 
    124 **/
    125 UINT64
    126 EFIAPI
    127 MmioWriteWorker (
    128   IN      UINTN                     Address,
    129   IN      EFI_SMM_IO_WIDTH          Width,
    130   IN      UINT64                    Data
    131   )
    132 {
    133   EFI_STATUS                        Status;
    134 
    135   Status = gSmst->SmmIo.Mem.Write (&gSmst->SmmIo, Width, Address, 1, &Data);
    136   ASSERT_EFI_ERROR (Status);
    137 
    138   return Data;
    139 }
    140 
    141 /**
    142   Reads an 8-bit I/O port.
    143 
    144   Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
    145   This function must guarantee that all I/O read and write operations are
    146   serialized.
    147 
    148   If 8-bit I/O port operations are not supported, then ASSERT().
    149 
    150   @param  Port  The I/O port to read.
    151 
    152   @return The value read.
    153 
    154 **/
    155 UINT8
    156 EFIAPI
    157 IoRead8 (
    158   IN      UINTN                     Port
    159   )
    160 {
    161   return (UINT8)IoReadWorker (Port, SMM_IO_UINT8);
    162 }
    163 
    164 /**
    165   Writes an 8-bit I/O port.
    166 
    167   Writes the 8-bit I/O port specified by Port with the value specified by Value
    168   and returns Value. This function must guarantee that all I/O read and write
    169   operations are serialized.
    170 
    171   If 8-bit I/O port operations are not supported, then ASSERT().
    172 
    173   @param  Port  The I/O port to write.
    174   @param  Value The value to write to the I/O port.
    175 
    176   @return The value written the I/O port.
    177 
    178 **/
    179 UINT8
    180 EFIAPI
    181 IoWrite8 (
    182   IN      UINTN                     Port,
    183   IN      UINT8                     Value
    184   )
    185 {
    186   return (UINT8)IoWriteWorker (Port, SMM_IO_UINT8, Value);
    187 }
    188 
    189 /**
    190   Reads a 16-bit I/O port.
    191 
    192   Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
    193   This function must guarantee that all I/O read and write operations are
    194   serialized.
    195 
    196   If Port is not aligned on a 16-bit boundary, then ASSERT().
    197 
    198   If 16-bit I/O port operations are not supported, then ASSERT().
    199 
    200   @param  Port  The I/O port to read.
    201 
    202   @return The value read.
    203 
    204 **/
    205 UINT16
    206 EFIAPI
    207 IoRead16 (
    208   IN      UINTN                     Port
    209   )
    210 {
    211   //
    212   // Make sure Port is aligned on a 16-bit boundary.
    213   //
    214   ASSERT ((Port & 1) == 0);
    215   return (UINT16)IoReadWorker (Port, SMM_IO_UINT16);
    216 }
    217 
    218 /**
    219   Writes a 16-bit I/O port.
    220 
    221   Writes the 16-bit I/O port specified by Port with the value specified by Value
    222   and returns Value. This function must guarantee that all I/O read and write
    223   operations are serialized.
    224 
    225   If Port is not aligned on a 16-bit boundary, then ASSERT().
    226 
    227   If 16-bit I/O port operations are not supported, then ASSERT().
    228 
    229   @param  Port  The I/O port to write.
    230   @param  Value The value to write to the I/O port.
    231 
    232   @return The value written the I/O port.
    233 
    234 **/
    235 UINT16
    236 EFIAPI
    237 IoWrite16 (
    238   IN      UINTN                     Port,
    239   IN      UINT16                    Value
    240   )
    241 {
    242   //
    243   // Make sure Port is aligned on a 16-bit boundary.
    244   //
    245   ASSERT ((Port & 1) == 0);
    246   return (UINT16)IoWriteWorker (Port, SMM_IO_UINT16, Value);
    247 }
    248 
    249 /**
    250   Reads a 32-bit I/O port.
    251 
    252   Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
    253   This function must guarantee that all I/O read and write operations are
    254   serialized.
    255 
    256   If Port is not aligned on a 32-bit boundary, then ASSERT().
    257 
    258   If 32-bit I/O port operations are not supported, then ASSERT().
    259 
    260   @param  Port  The I/O port to read.
    261 
    262   @return The value read.
    263 
    264 **/
    265 UINT32
    266 EFIAPI
    267 IoRead32 (
    268   IN      UINTN                     Port
    269   )
    270 {
    271   //
    272   // Make sure Port is aligned on a 32-bit boundary.
    273   //
    274   ASSERT ((Port & 3) == 0);
    275   return (UINT32)IoReadWorker (Port, SMM_IO_UINT32);
    276 }
    277 
    278 /**
    279   Writes a 32-bit I/O port.
    280 
    281   Writes the 32-bit I/O port specified by Port with the value specified by Value
    282   and returns Value. This function must guarantee that all I/O read and write
    283   operations are serialized.
    284 
    285   If Port is not aligned on a 32-bit boundary, then ASSERT().
    286 
    287   If 32-bit I/O port operations are not supported, then ASSERT().
    288 
    289   @param  Port  The I/O port to write.
    290   @param  Value The value to write to the I/O port.
    291 
    292   @return The value written the I/O port.
    293 
    294 **/
    295 UINT32
    296 EFIAPI
    297 IoWrite32 (
    298   IN      UINTN                     Port,
    299   IN      UINT32                    Value
    300   )
    301 {
    302   //
    303   // Make sure Port is aligned on a 32-bit boundary.
    304   //
    305   ASSERT ((Port & 3) == 0);
    306   return (UINT32)IoWriteWorker (Port, SMM_IO_UINT32, Value);
    307 }
    308 
    309 /**
    310   Reads a 64-bit I/O port.
    311 
    312   Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
    313   This function must guarantee that all I/O read and write operations are
    314   serialized.
    315 
    316   If Port is not aligned on a 64-bit boundary, then ASSERT().
    317 
    318   If 64-bit I/O port operations are not supported, then ASSERT().
    319 
    320   @param  Port  The I/O port to read.
    321 
    322   @return The value read.
    323 
    324 **/
    325 UINT64
    326 EFIAPI
    327 IoRead64 (
    328   IN      UINTN                     Port
    329   )
    330 {
    331   //
    332   // Make sure Port is aligned on a 64-bit boundary.
    333   //
    334   ASSERT ((Port & 7) == 0);
    335   return IoReadWorker (Port, SMM_IO_UINT64);
    336 }
    337 
    338 /**
    339   Writes a 64-bit I/O port.
    340 
    341   Writes the 64-bit I/O port specified by Port with the value specified by Value
    342   and returns Value. This function must guarantee that all I/O read and write
    343   operations are serialized.
    344 
    345   If Port is not aligned on a 64-bit boundary, then ASSERT().
    346 
    347   If 64-bit I/O port operations are not supported, then ASSERT().
    348 
    349   @param  Port  The I/O port to write.
    350   @param  Value The value to write to the I/O port.
    351 
    352   @return The value written the I/O port.
    353 
    354 **/
    355 UINT64
    356 EFIAPI
    357 IoWrite64 (
    358   IN      UINTN                     Port,
    359   IN      UINT64                    Value
    360   )
    361 {
    362   //
    363   // Make sure Port is aligned on a 64-bit boundary.
    364   //
    365   ASSERT ((Port & 7) == 0);
    366   return IoWriteWorker (Port, SMM_IO_UINT64, Value);
    367 }
    368 
    369 /**
    370   Reads an 8-bit MMIO register.
    371 
    372   Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
    373   returned. This function must guarantee that all MMIO read and write
    374   operations are serialized.
    375 
    376   If 8-bit MMIO register operations are not supported, then ASSERT().
    377 
    378   @param  Address The MMIO register to read.
    379 
    380   @return The value read.
    381 
    382 **/
    383 UINT8
    384 EFIAPI
    385 MmioRead8 (
    386   IN      UINTN                     Address
    387   )
    388 {
    389   return (UINT8)MmioReadWorker (Address, SMM_IO_UINT8);
    390 }
    391 
    392 /**
    393   Writes an 8-bit MMIO register.
    394 
    395   Writes the 8-bit MMIO register specified by Address with the value specified
    396   by Value and returns Value. This function must guarantee that all MMIO read
    397   and write operations are serialized.
    398 
    399   If 8-bit MMIO register operations are not supported, then ASSERT().
    400 
    401   @param  Address The MMIO register to write.
    402   @param  Value   The value to write to the MMIO register.
    403 
    404 **/
    405 UINT8
    406 EFIAPI
    407 MmioWrite8 (
    408   IN      UINTN                     Address,
    409   IN      UINT8                     Value
    410   )
    411 {
    412   return (UINT8)MmioWriteWorker (Address, SMM_IO_UINT8, Value);
    413 }
    414 
    415 /**
    416   Reads a 16-bit MMIO register.
    417 
    418   Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
    419   returned. This function must guarantee that all MMIO read and write
    420   operations are serialized.
    421 
    422   If Address is not aligned on a 16-bit boundary, then ASSERT().
    423 
    424   If 16-bit MMIO register operations are not supported, then ASSERT().
    425 
    426   @param  Address The MMIO register to read.
    427 
    428   @return The value read.
    429 
    430 **/
    431 UINT16
    432 EFIAPI
    433 MmioRead16 (
    434   IN      UINTN                     Address
    435   )
    436 {
    437   //
    438   // Make sure Address is aligned on a 16-bit boundary.
    439   //
    440   ASSERT ((Address & 1) == 0);
    441   return (UINT16)MmioReadWorker (Address, SMM_IO_UINT16);
    442 }
    443 
    444 /**
    445   Writes a 16-bit MMIO register.
    446 
    447   Writes the 16-bit MMIO register specified by Address with the value specified
    448   by Value and returns Value. This function must guarantee that all MMIO read
    449   and write operations are serialized.
    450 
    451   If Address is not aligned on a 16-bit boundary, then ASSERT().
    452 
    453   If 16-bit MMIO register operations are not supported, then ASSERT().
    454 
    455   @param  Address The MMIO register to write.
    456   @param  Value   The value to write to the MMIO register.
    457 
    458 **/
    459 UINT16
    460 EFIAPI
    461 MmioWrite16 (
    462   IN      UINTN                     Address,
    463   IN      UINT16                    Value
    464   )
    465 {
    466   //
    467   // Make sure Address is aligned on a 16-bit boundary.
    468   //
    469   ASSERT ((Address & 1) == 0);
    470   return (UINT16)MmioWriteWorker (Address, SMM_IO_UINT16, Value);
    471 }
    472 
    473 /**
    474   Reads a 32-bit MMIO register.
    475 
    476   Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
    477   returned. This function must guarantee that all MMIO read and write
    478   operations are serialized.
    479 
    480   If Address is not aligned on a 32-bit boundary, then ASSERT().
    481 
    482   If 32-bit MMIO register operations are not supported, then ASSERT().
    483 
    484   @param  Address The MMIO register to read.
    485 
    486   @return The value read.
    487 
    488 **/
    489 UINT32
    490 EFIAPI
    491 MmioRead32 (
    492   IN      UINTN                     Address
    493   )
    494 {
    495   //
    496   // Make sure Address is aligned on a 32-bit boundary.
    497   //
    498   ASSERT ((Address & 3) == 0);
    499   return (UINT32)MmioReadWorker (Address, SMM_IO_UINT32);
    500 }
    501 
    502 /**
    503   Writes a 32-bit MMIO register.
    504 
    505   Writes the 32-bit MMIO register specified by Address with the value specified
    506   by Value and returns Value. This function must guarantee that all MMIO read
    507   and write operations are serialized.
    508 
    509   If Address is not aligned on a 32-bit boundary, then ASSERT().
    510 
    511   If 32-bit MMIO register operations are not supported, then ASSERT().
    512 
    513   @param  Address The MMIO register to write.
    514   @param  Value   The value to write to the MMIO register.
    515 
    516 **/
    517 UINT32
    518 EFIAPI
    519 MmioWrite32 (
    520   IN      UINTN                     Address,
    521   IN      UINT32                    Value
    522   )
    523 {
    524   //
    525   // Make sure Address is aligned on a 32-bit boundary.
    526   //
    527   ASSERT ((Address & 3) == 0);
    528   return (UINT32)MmioWriteWorker (Address, SMM_IO_UINT32, Value);
    529 }
    530 
    531 /**
    532   Reads a 64-bit MMIO register.
    533 
    534   Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
    535   returned. This function must guarantee that all MMIO read and write
    536   operations are serialized.
    537 
    538   If Address is not aligned on a 64-bit boundary, then ASSERT().
    539 
    540   If 64-bit MMIO register operations are not supported, then ASSERT().
    541 
    542   @param  Address The MMIO register to read.
    543 
    544   @return The value read.
    545 
    546 **/
    547 UINT64
    548 EFIAPI
    549 MmioRead64 (
    550   IN      UINTN                     Address
    551   )
    552 {
    553   //
    554   // Make sure Address is aligned on a 64-bit boundary.
    555   //
    556   ASSERT ((Address & 7) == 0);
    557   return (UINT64)MmioReadWorker (Address, SMM_IO_UINT64);
    558 }
    559 
    560 /**
    561   Writes a 64-bit MMIO register.
    562 
    563   Writes the 64-bit MMIO register specified by Address with the value specified
    564   by Value and returns Value. This function must guarantee that all MMIO read
    565   and write operations are serialized.
    566 
    567   If Address is not aligned on a 64-bit boundary, then ASSERT().
    568 
    569   If 64-bit MMIO register operations are not supported, then ASSERT().
    570 
    571   @param  Address The MMIO register to write.
    572   @param  Value   The value to write to the MMIO register.
    573 
    574 **/
    575 UINT64
    576 EFIAPI
    577 MmioWrite64 (
    578   IN      UINTN                     Address,
    579   IN      UINT64                    Value
    580   )
    581 {
    582   //
    583   // Make sure Address is aligned on a 64-bit boundary.
    584   //
    585   ASSERT ((Address & 7) == 0);
    586   return (UINT64)MmioWriteWorker (Address, SMM_IO_UINT64, Value);
    587 }
    588