MdePkg/Library/PeiIoLibCpuIo/IoLib.c

   1 /** @file
   2   I/O Library.
   3
   4   Copyright (c) 2006, 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   Module Name:  IoLib.c
  14
  15 **/
  16
  17 /**
  18   Reads an 8-bit I/O port.
  19
  20   Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
  21   This function must guarantee that all I/O read and write operations are
  22   serialized.
  23
  24   If 8-bit I/O port operations are not supported, then ASSERT().
  25
  26   @param  Port  The I/O port to read.
  27
  28   @return The value read.
  29
  30 **/
  31 UINT8
  32 EFIAPI
  33 IoRead8 (
  34   IN      UINTN                     Port
  35   )
  36 {
  37   EFI_PEI_SERVICES                  **PeiServices;
  38   EFI_PEI_CPU_IO_PPI                *CpuIo;
  39
  40   PeiServices = GetPeiServicesTablePointer ();
  41   CpuIo       = (*PeiServices)->CpuIo;
  42   ASSERT (CpuIo != NULL);
  43
  44   return CpuIo->IoRead8 (PeiServices, CpuIo, (UINT64) Port);
  45 }
  46
  47 /**
  48   Writes an 8-bit I/O port.
  49
  50   Writes the 8-bit I/O port specified by Port with the value specified by Value
  51   and returns Value. This function must guarantee that all I/O read and write
  52   operations are serialized.
  53
  54   If 8-bit I/O port operations are not supported, then ASSERT().
  55
  56   @param  Port  The I/O port to write.
  57   @param  Value The value to write to the I/O port.
  58
  59   @return The value written the I/O port.
  60
  61 **/
  62 UINT8
  63 EFIAPI
  64 IoWrite8 (
  65   IN      UINTN                     Port,
  66   IN      UINT8                     Value
  67   )
  68 {
  69   EFI_PEI_SERVICES                  **PeiServices;
  70   EFI_PEI_CPU_IO_PPI                *CpuIo;
  71
  72   PeiServices = GetPeiServicesTablePointer ();
  73   CpuIo       = (*PeiServices)->CpuIo;
  74   ASSERT (CpuIo != NULL);
  75
  76   CpuIo->IoWrite8 (PeiServices, CpuIo, (UINT64) Port, Value);
  77   return Value;
  78 }
  79
  80 /**
  81   Reads a 16-bit I/O port.
  82
  83   Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
  84   This function must guarantee that all I/O read and write operations are
  85   serialized.
  86
  87   If 16-bit I/O port operations are not supported, then ASSERT().
  88
  89   @param  Port  The I/O port to read.
  90
  91   @return The value read.
  92
  93 **/
  94 UINT16
  95 EFIAPI
  96 IoRead16 (
  97   IN      UINTN                     Port
  98   )
  99 {
 100   EFI_PEI_SERVICES                  **PeiServices;
 101   EFI_PEI_CPU_IO_PPI                *CpuIo;
 102
 103   PeiServices = GetPeiServicesTablePointer ();
 104   CpuIo       = (*PeiServices)->CpuIo;
 105   ASSERT (CpuIo != NULL);
 106   //
 107   // Make sure Port is aligned on a 16-bit boundary.
 108   //
 109   ASSERT ((Port & 1) == 0);
 110   return CpuIo->IoRead16 (PeiServices, CpuIo, (UINT64) Port);
 111 }
 112
 113 /**
 114   Writes a 16-bit I/O port.
 115
 116   Writes the 16-bit I/O port specified by Port with the value specified by Value
 117   and returns Value. This function must guarantee that all I/O read and write
 118   operations are serialized.
 119
 120   If 16-bit I/O port operations are not supported, then ASSERT().
 121
 122   @param  Port  The I/O port to write.
 123   @param  Value The value to write to the I/O port.
 124
 125   @return The value written the I/O port.
 126
 127 **/
 128 UINT16
 129 EFIAPI
 130 IoWrite16 (
 131   IN      UINTN                     Port,
 132   IN      UINT16                    Value
 133   )
 134 {
 135   EFI_PEI_SERVICES                  **PeiServices;
 136   EFI_PEI_CPU_IO_PPI                *CpuIo;
 137
 138   PeiServices = GetPeiServicesTablePointer ();
 139   CpuIo       = (*PeiServices)->CpuIo;
 140   ASSERT (CpuIo != NULL);
 141   //
 142   // Make sure Port is aligned on a 16-bit boundary.
 143   //
 144   ASSERT ((Port & 1) == 0);
 145   CpuIo->IoWrite16 (PeiServices, CpuIo, (UINT64) Port, Value);
 146   return Value;
 147 }
 148
 149 /**
 150   Reads a 32-bit I/O port.
 151
 152   Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
 153   This function must guarantee that all I/O read and write operations are
 154   serialized.
 155
 156   If 32-bit I/O port operations are not supported, then ASSERT().
 157
 158   @param  Port  The I/O port to read.
 159
 160   @return The value read.
 161
 162 **/
 163 UINT32
 164 EFIAPI
 165 IoRead32 (
 166   IN      UINTN                     Port
 167   )
 168 {
 169   EFI_PEI_SERVICES                  **PeiServices;
 170   EFI_PEI_CPU_IO_PPI                *CpuIo;
 171
 172   PeiServices = GetPeiServicesTablePointer ();
 173   CpuIo       = (*PeiServices)->CpuIo;
 174   ASSERT (CpuIo != NULL);
 175   //
 176   // Make sure Port is aligned on a 32-bit boundary.
 177   //
 178   ASSERT ((Port & 3) == 0);
 179   return CpuIo->IoRead32 (PeiServices, CpuIo, (UINT64) Port);
 180 }
 181
 182 /**
 183   Writes a 32-bit I/O port.
 184
 185   Writes the 32-bit I/O port specified by Port with the value specified by Value
 186   and returns Value. This function must guarantee that all I/O read and write
 187   operations are serialized.
 188
 189   If 32-bit I/O port operations are not supported, then ASSERT().
 190
 191   @param  Port  The I/O port to write.
 192   @param  Value The value to write to the I/O port.
 193
 194   @return The value written the I/O port.
 195
 196 **/
 197 UINT32
 198 EFIAPI
 199 IoWrite32 (
 200   IN      UINTN                     Port,
 201   IN      UINT32                    Value
 202   )
 203 {
 204   EFI_PEI_SERVICES                  **PeiServices;
 205   EFI_PEI_CPU_IO_PPI                *CpuIo;
 206
 207   PeiServices = GetPeiServicesTablePointer ();
 208   CpuIo       = (*PeiServices)->CpuIo;
 209   ASSERT (CpuIo != NULL);
 210   //
 211   // Make sure Port is aligned on a 32-bit boundary.
 212   //
 213   ASSERT ((Port & 3) == 0);
 214   CpuIo->IoWrite32 (PeiServices, CpuIo, (UINT64) Port, Value);
 215   return Value;
 216 }
 217
 218 /**
 219   Reads a 64-bit I/O port.
 220
 221   Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
 222   This function must guarantee that all I/O read and write operations are
 223   serialized.
 224
 225   If 64-bit I/O port operations are not supported, then ASSERT().
 226
 227   @param  Port  The I/O port to read.
 228
 229   @return The value read.
 230
 231 **/
 232 UINT64
 233 EFIAPI
 234 IoRead64 (
 235   IN      UINTN                     Port
 236   )
 237 {
 238   EFI_PEI_SERVICES                  **PeiServices;
 239   EFI_PEI_CPU_IO_PPI                *CpuIo;
 240
 241   PeiServices = GetPeiServicesTablePointer ();
 242   CpuIo       = (*PeiServices)->CpuIo;
 243   ASSERT (CpuIo != NULL);
 244   //
 245   // Make sure Port is aligned on a 64-bit boundary.
 246   //
 247   ASSERT ((Port & 7) == 0);
 248   return CpuIo->IoRead64 (PeiServices, CpuIo, (UINT64) Port);
 249 }
 250
 251 /**
 252   Writes a 64-bit I/O port.
 253
 254   Writes the 64-bit I/O port specified by Port with the value specified by Value
 255   and returns Value. This function must guarantee that all I/O read and write
 256   operations are serialized.
 257
 258   If 64-bit I/O port operations are not supported, then ASSERT().
 259
 260   @param  Port  The I/O port to write.
 261   @param  Value The value to write to the I/O port.
 262
 263   @return The value written the I/O port.
 264
 265 **/
 266 UINT64
 267 EFIAPI
 268 IoWrite64 (
 269   IN      UINTN                     Port,
 270   IN      UINT64                    Value
 271   )
 272 {
 273   EFI_PEI_SERVICES                  **PeiServices;
 274   EFI_PEI_CPU_IO_PPI                *CpuIo;
 275
 276   PeiServices = GetPeiServicesTablePointer ();
 277   CpuIo       = (*PeiServices)->CpuIo;
 278   ASSERT (CpuIo != NULL);
 279   //
 280   // Make sure Port is aligned on a 64-bit boundary.
 281   //
 282   ASSERT ((Port & 7) == 0);
 283   CpuIo->IoWrite64 (PeiServices, CpuIo, (UINT64) Port, Value);
 284   return Value;;
 285 }
 286
 287 /**
 288   Reads an 8-bit MMIO register.
 289
 290   Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
 291   returned. This function must guarantee that all MMIO read and write
 292   operations are serialized.
 293
 294   If 8-bit MMIO register operations are not supported, then ASSERT().
 295
 296   @param  Address The MMIO register to read.
 297
 298   @return The value read.
 299
 300 **/
 301 UINT8
 302 EFIAPI
 303 MmioRead8 (
 304   IN      UINTN                     Address
 305   )
 306 {
 307   EFI_PEI_SERVICES                  **PeiServices;
 308   EFI_PEI_CPU_IO_PPI                *CpuIo;
 309
 310   PeiServices = GetPeiServicesTablePointer ();
 311   CpuIo       = (*PeiServices)->CpuIo;
 312   ASSERT (CpuIo != NULL);
 313
 314   return CpuIo->MemRead8 (PeiServices, CpuIo, (UINT64) Address);
 315 }
 316
 317 /**
 318   Writes an 8-bit MMIO register.
 319
 320   Writes the 8-bit MMIO register specified by Address with the value specified
 321   by Value and returns Value. This function must guarantee that all MMIO read
 322   and write operations are serialized.
 323
 324   If 8-bit MMIO register operations are not supported, then ASSERT().
 325
 326   @param  Address The MMIO register to write.
 327   @param  Value   The value to write to the MMIO register.
 328
 329 **/
 330 UINT8
 331 EFIAPI
 332 MmioWrite8 (
 333   IN      UINTN                     Address,
 334   IN      UINT8                     Value
 335   )
 336 {
 337   EFI_PEI_SERVICES                  **PeiServices;
 338   EFI_PEI_CPU_IO_PPI                *CpuIo;
 339
 340   PeiServices = GetPeiServicesTablePointer ();
 341   CpuIo       = (*PeiServices)->CpuIo;
 342   ASSERT (CpuIo != NULL);
 343
 344   CpuIo->MemWrite8 (PeiServices, CpuIo, (UINT64) Address, Value);
 345   return Value;
 346 }
 347
 348 /**
 349   Reads a 16-bit MMIO register.
 350
 351   Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
 352   returned. This function must guarantee that all MMIO read and write
 353   operations are serialized.
 354
 355   If 16-bit MMIO register operations are not supported, then ASSERT().
 356
 357   @param  Address The MMIO register to read.
 358
 359   @return The value read.
 360
 361 **/
 362 UINT16
 363 EFIAPI
 364 MmioRead16 (
 365   IN      UINTN                     Address
 366   )
 367 {
 368   EFI_PEI_SERVICES                  **PeiServices;
 369   EFI_PEI_CPU_IO_PPI                *CpuIo;
 370
 371   PeiServices = GetPeiServicesTablePointer ();
 372   CpuIo       = (*PeiServices)->CpuIo;
 373   ASSERT (CpuIo != NULL);
 374   //
 375   // Make sure Address is aligned on a 16-bit boundary.
 376   //
 377   ASSERT ((Address & 1) == 0);
 378   return CpuIo->MemRead16 (PeiServices, CpuIo, (UINT64) Address);
 379
 380 }
 381
 382 /**
 383   Writes a 16-bit MMIO register.
 384
 385   Writes the 16-bit MMIO register specified by Address with the value specified
 386   by Value and returns Value. This function must guarantee that all MMIO read
 387   and write operations are serialized.
 388
 389   If 16-bit MMIO register operations are not supported, then ASSERT().
 390
 391   @param  Address The MMIO register to write.
 392   @param  Value   The value to write to the MMIO register.
 393
 394 **/
 395 UINT16
 396 EFIAPI
 397 MmioWrite16 (
 398   IN      UINTN                     Address,
 399   IN      UINT16                    Value
 400   )
 401 {
 402   EFI_PEI_SERVICES                  **PeiServices;
 403   EFI_PEI_CPU_IO_PPI                *CpuIo;
 404
 405   PeiServices = GetPeiServicesTablePointer ();
 406   CpuIo       = (*PeiServices)->CpuIo;
 407   ASSERT (CpuIo != NULL);
 408   //
 409   // Make sure Address is aligned on a 16-bit boundary.
 410   //
 411   ASSERT ((Address & 1) == 0);
 412   CpuIo->MemWrite16 (PeiServices, CpuIo, (UINT64) Address, Value);
 413   return Value;
 414 }
 415
 416 /**
 417   Reads a 32-bit MMIO register.
 418
 419   Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
 420   returned. This function must guarantee that all MMIO read and write
 421   operations are serialized.
 422
 423   If 32-bit MMIO register operations are not supported, then ASSERT().
 424
 425   @param  Address The MMIO register to read.
 426
 427   @return The value read.
 428
 429 **/
 430 UINT32
 431 EFIAPI
 432 MmioRead32 (
 433   IN      UINTN                     Address
 434   )
 435 {
 436   EFI_PEI_SERVICES                  **PeiServices;
 437   EFI_PEI_CPU_IO_PPI                *CpuIo;
 438
 439   PeiServices = GetPeiServicesTablePointer ();
 440   CpuIo       = (*PeiServices)->CpuIo;
 441   ASSERT (CpuIo != NULL);
 442   //
 443   // Make sure Address is aligned on a 32-bit boundary.
 444   //
 445   ASSERT ((Address & 3) == 0);
 446   return CpuIo->MemRead32 (PeiServices, CpuIo, (UINT64) Address);
 447
 448 }
 449
 450 /**
 451   Writes a 32-bit MMIO register.
 452
 453   Writes the 32-bit MMIO register specified by Address with the value specified
 454   by Value and returns Value. This function must guarantee that all MMIO read
 455   and write operations are serialized.
 456
 457   If 32-bit MMIO register operations are not supported, then ASSERT().
 458
 459   @param  Address The MMIO register to write.
 460   @param  Value   The value to write to the MMIO register.
 461
 462 **/
 463 UINT32
 464 EFIAPI
 465 MmioWrite32 (
 466   IN      UINTN                     Address,
 467   IN      UINT32                    Value
 468   )
 469 {
 470   EFI_PEI_SERVICES                  **PeiServices;
 471   EFI_PEI_CPU_IO_PPI                *CpuIo;
 472
 473   PeiServices = GetPeiServicesTablePointer ();
 474   CpuIo       = (*PeiServices)->CpuIo;
 475   ASSERT (CpuIo != NULL);
 476   //
 477   // Make sure Address is aligned on a 32-bit boundary.
 478   //
 479   ASSERT ((Address & 3) == 0);
 480   CpuIo->MemWrite32 (PeiServices, CpuIo, (UINT64) Address, Value);
 481   return Value;
 482 }
 483
 484 /**
 485   Reads a 64-bit MMIO register.
 486
 487   Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
 488   returned. This function must guarantee that all MMIO read and write
 489   operations are serialized.
 490
 491   If 64-bit MMIO register operations are not supported, then ASSERT().
 492
 493   @param  Address The MMIO register to read.
 494
 495   @return The value read.
 496
 497 **/
 498 UINT64
 499 EFIAPI
 500 MmioRead64 (
 501   IN      UINTN                     Address
 502   )
 503 {
 504   EFI_PEI_SERVICES                  **PeiServices;
 505   EFI_PEI_CPU_IO_PPI                *CpuIo;
 506
 507   PeiServices = GetPeiServicesTablePointer ();
 508   CpuIo       = (*PeiServices)->CpuIo;
 509   ASSERT (CpuIo != NULL);
 510   //
 511   // Make sure Address is aligned on a 64-bit boundary.
 512   //
 513   ASSERT ((Address & 7) == 0);
 514   return CpuIo->MemRead64 (PeiServices, CpuIo, (UINT64) Address);
 515
 516 }
 517
 518 /**
 519   Writes a 64-bit MMIO register.
 520
 521   Writes the 64-bit MMIO register specified by Address with the value specified
 522   by Value and returns Value. This function must guarantee that all MMIO read
 523   and write operations are serialized.
 524
 525   If 64-bit MMIO register operations are not supported, then ASSERT().
 526
 527   @param  Address The MMIO register to write.
 528   @param  Value   The value to write to the MMIO register.
 529
 530 **/
 531 UINT64
 532 EFIAPI
 533 MmioWrite64 (
 534   IN      UINTN                     Address,
 535   IN      UINT64                    Value
 536   )
 537 {
 538   EFI_PEI_SERVICES                  **PeiServices;
 539   EFI_PEI_CPU_IO_PPI                *CpuIo;
 540
 541   PeiServices = GetPeiServicesTablePointer ();
 542   CpuIo       = (*PeiServices)->CpuIo;
 543   ASSERT (CpuIo != NULL);
 544   //
 545   // Make sure Address is aligned on a 64-bit boundary.
 546   //
 547   ASSERT ((Address & 7) == 0);
 548   CpuIo->MemWrite64 (PeiServices, CpuIo, (UINT64) Address, Value);
 549   return Value;
 550 }