MdePkg/Library/BaseIoLibIntrinsic/IoLibNoIo.c

   1 /** @file
   2   I/O library for non I/O read and write access (memory map I/O read and
   3   write only) architecture, such as ARM and RISC-V processor.
   4
   5   Copyright (c) 2006 - 2021, Intel Corporation. All rights reserved.<BR>
   6   Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
   7   Copyright (c) 2017, AMD Incorporated. All rights reserved.<BR>
   8   Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR>
   9
  10   SPDX-License-Identifier: BSD-2-Clause-Patent
  11
  12 **/
  13
  14
  15 //
  16 // Include common header file for this module.
  17 //
  18 #include "BaseIoLibIntrinsicInternal.h"
  19
  20 /**
  21   Reads an 8-bit I/O port.
  22
  23   Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
  24   This function must guarantee that all I/O read and write operations are
  25   serialized.
  26
  27   If 8-bit I/O port operations are not supported, then ASSERT().
  28
  29   @param  Port  The I/O port to read.
  30
  31   @return The value read.
  32
  33 **/
  34 UINT8
  35 EFIAPI
  36 IoRead8 (
  37   IN      UINTN                     Port
  38   )
  39 {
  40   ASSERT (FALSE);
  41   return 0;
  42 }
  43
  44 /**
  45   Writes an 8-bit I/O port.
  46
  47   Writes the 8-bit I/O port specified by Port with the value specified by Value
  48   and returns Value. This function must guarantee that all I/O read and write
  49   operations are serialized.
  50
  51   If 8-bit I/O port operations are not supported, then ASSERT().
  52
  53   @param  Port  The I/O port to write.
  54   @param  Value The value to write to the I/O port.
  55
  56   @return The value written the I/O port.
  57
  58 **/
  59 UINT8
  60 EFIAPI
  61 IoWrite8 (
  62   IN      UINTN                     Port,
  63   IN      UINT8                     Value
  64   )
  65 {
  66   ASSERT (FALSE);
  67   return Value;
  68 }
  69
  70 /**
  71   Reads a 16-bit I/O port.
  72
  73   Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
  74   This function must guarantee that all I/O read and write operations are
  75   serialized.
  76
  77   If 16-bit I/O port operations are not supported, then ASSERT().
  78
  79   @param  Port  The I/O port to read.
  80
  81   @return The value read.
  82
  83 **/
  84 UINT16
  85 EFIAPI
  86 IoRead16 (
  87   IN      UINTN                     Port
  88   )
  89 {
  90   ASSERT (FALSE);
  91   return 0;
  92 }
  93
  94 /**
  95   Writes a 16-bit I/O port.
  96
  97   Writes the 16-bit I/O port specified by Port with the value specified by Value
  98   and returns Value. This function must guarantee that all I/O read and write
  99   operations are serialized.
 100
 101   If 16-bit I/O port operations are not supported, then ASSERT().
 102
 103   @param  Port  The I/O port to write.
 104   @param  Value The value to write to the I/O port.
 105
 106   @return The value written the I/O port.
 107
 108 **/
 109 UINT16
 110 EFIAPI
 111 IoWrite16 (
 112   IN      UINTN                     Port,
 113   IN      UINT16                    Value
 114   )
 115 {
 116   ASSERT (FALSE);
 117   return Value;
 118 }
 119
 120 /**
 121   Reads a 32-bit I/O port.
 122
 123   Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
 124   This function must guarantee that all I/O read and write operations are
 125   serialized.
 126
 127   If 32-bit I/O port operations are not supported, then ASSERT().
 128
 129   @param  Port  The I/O port to read.
 130
 131   @return The value read.
 132
 133 **/
 134 UINT32
 135 EFIAPI
 136 IoRead32 (
 137   IN      UINTN                     Port
 138   )
 139 {
 140   ASSERT (FALSE);
 141   return 0;
 142 }
 143
 144 /**
 145   Writes a 32-bit I/O port.
 146
 147   Writes the 32-bit I/O port specified by Port with the value specified by Value
 148   and returns Value. This function must guarantee that all I/O read and write
 149   operations are serialized.
 150
 151   If 32-bit I/O port operations are not supported, then ASSERT().
 152
 153   @param  Port  The I/O port to write.
 154   @param  Value The value to write to the I/O port.
 155
 156   @return The value written the I/O port.
 157
 158 **/
 159 UINT32
 160 EFIAPI
 161 IoWrite32 (
 162   IN      UINTN                     Port,
 163   IN      UINT32                    Value
 164   )
 165 {
 166   ASSERT (FALSE);
 167   return Value;
 168 }
 169
 170 /**
 171   Reads a 64-bit I/O port.
 172
 173   Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
 174   This function must guarantee that all I/O read and write operations are
 175   serialized.
 176
 177   If 64-bit I/O port operations are not supported, then ASSERT().
 178   If Port is not aligned on a 64-bit boundary, then ASSERT().
 179
 180   @param  Port  The I/O port to read.
 181
 182   @return The value read.
 183
 184 **/
 185 UINT64
 186 EFIAPI
 187 IoRead64 (
 188   IN      UINTN                     Port
 189   )
 190 {
 191   ASSERT (FALSE);
 192   return 0;
 193 }
 194
 195 /**
 196   Writes a 64-bit I/O port.
 197
 198   Writes the 64-bit I/O port specified by Port with the value specified by Value
 199   and returns Value. This function must guarantee that all I/O read and write
 200   operations are serialized.
 201
 202   If 64-bit I/O port operations are not supported, then ASSERT().
 203   If Port is not aligned on a 64-bit boundary, then ASSERT().
 204
 205   @param  Port  The I/O port to write.
 206   @param  Value The value to write to the I/O port.
 207
 208   @return The value written to the I/O port.
 209
 210 **/
 211 UINT64
 212 EFIAPI
 213 IoWrite64 (
 214   IN      UINTN                     Port,
 215   IN      UINT64                    Value
 216   )
 217 {
 218   ASSERT (FALSE);
 219   return 0;
 220 }
 221
 222 /**
 223   Reads an 8-bit I/O port fifo into a block of memory.
 224
 225   Reads the 8-bit I/O fifo port specified by Port.
 226   The port is read Count times, and the read data is
 227   stored in the provided Buffer.
 228
 229   This function must guarantee that all I/O read and write operations are
 230   serialized.
 231
 232   If 8-bit I/O port operations are not supported, then ASSERT().
 233
 234   @param  Port    The I/O port to read.
 235   @param  Count   The number of times to read I/O port.
 236   @param  Buffer  The buffer to store the read data into.
 237
 238 **/
 239 VOID
 240 EFIAPI
 241 IoReadFifo8 (
 242   IN      UINTN                     Port,
 243   IN      UINTN                     Count,
 244   OUT     VOID                      *Buffer
 245   )
 246 {
 247   ASSERT (FALSE);
 248 }
 249
 250 /**
 251   Writes a block of memory into an 8-bit I/O port fifo.
 252
 253   Writes the 8-bit I/O fifo port specified by Port.
 254   The port is written Count times, and the write data is
 255   retrieved from the provided Buffer.
 256
 257   This function must guarantee that all I/O write and write operations are
 258   serialized.
 259
 260   If 8-bit I/O port operations are not supported, then ASSERT().
 261
 262   @param  Port    The I/O port to write.
 263   @param  Count   The number of times to write I/O port.
 264   @param  Buffer  The buffer to retrieve the write data from.
 265
 266 **/
 267 VOID
 268 EFIAPI
 269 IoWriteFifo8 (
 270   IN      UINTN                     Port,
 271   IN      UINTN                     Count,
 272   IN      VOID                      *Buffer
 273   )
 274 {
 275   ASSERT (FALSE);
 276 }
 277
 278 /**
 279   Reads a 16-bit I/O port fifo into a block of memory.
 280
 281   Reads the 16-bit I/O fifo port specified by Port.
 282   The port is read Count times, and the read data is
 283   stored in the provided Buffer.
 284
 285   This function must guarantee that all I/O read and write operations are
 286   serialized.
 287
 288   If 16-bit I/O port operations are not supported, then ASSERT().
 289
 290   @param  Port    The I/O port to read.
 291   @param  Count   The number of times to read I/O port.
 292   @param  Buffer  The buffer to store the read data into.
 293
 294 **/
 295 VOID
 296 EFIAPI
 297 IoReadFifo16 (
 298   IN      UINTN                     Port,
 299   IN      UINTN                     Count,
 300   OUT     VOID                      *Buffer
 301   )
 302 {
 303   ASSERT (FALSE);
 304 }
 305
 306 /**
 307   Writes a block of memory into a 16-bit I/O port fifo.
 308
 309   Writes the 16-bit I/O fifo port specified by Port.
 310   The port is written Count times, and the write data is
 311   retrieved from the provided Buffer.
 312
 313   This function must guarantee that all I/O write and write operations are
 314   serialized.
 315
 316   If 16-bit I/O port operations are not supported, then ASSERT().
 317
 318   @param  Port    The I/O port to write.
 319   @param  Count   The number of times to write I/O port.
 320   @param  Buffer  The buffer to retrieve the write data from.
 321
 322 **/
 323 VOID
 324 EFIAPI
 325 IoWriteFifo16 (
 326   IN      UINTN                     Port,
 327   IN      UINTN                     Count,
 328   IN      VOID                      *Buffer
 329   )
 330 {
 331   ASSERT (FALSE);
 332 }
 333
 334 /**
 335   Reads a 32-bit I/O port fifo into a block of memory.
 336
 337   Reads the 32-bit I/O fifo port specified by Port.
 338   The port is read Count times, and the read data is
 339   stored in the provided Buffer.
 340
 341   This function must guarantee that all I/O read and write operations are
 342   serialized.
 343
 344   If 32-bit I/O port operations are not supported, then ASSERT().
 345
 346   @param  Port    The I/O port to read.
 347   @param  Count   The number of times to read I/O port.
 348   @param  Buffer  The buffer to store the read data into.
 349
 350 **/
 351 VOID
 352 EFIAPI
 353 IoReadFifo32 (
 354   IN      UINTN                     Port,
 355   IN      UINTN                     Count,
 356   OUT     VOID                      *Buffer
 357   )
 358 {
 359   ASSERT (FALSE);
 360 }
 361
 362 /**
 363   Writes a block of memory into a 32-bit I/O port fifo.
 364
 365   Writes the 32-bit I/O fifo port specified by Port.
 366   The port is written Count times, and the write data is
 367   retrieved from the provided Buffer.
 368
 369   This function must guarantee that all I/O write and write operations are
 370   serialized.
 371
 372   If 32-bit I/O port operations are not supported, then ASSERT().
 373
 374   @param  Port    The I/O port to write.
 375   @param  Count   The number of times to write I/O port.
 376   @param  Buffer  The buffer to retrieve the write data from.
 377
 378 **/
 379 VOID
 380 EFIAPI
 381 IoWriteFifo32 (
 382   IN      UINTN                     Port,
 383   IN      UINTN                     Count,
 384   IN      VOID                      *Buffer
 385   )
 386 {
 387   ASSERT (FALSE);
 388 }
 389
 390 /**
 391   Reads an 8-bit MMIO register.
 392
 393   Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
 394   returned. This function must guarantee that all MMIO read and write
 395   operations are serialized.
 396
 397   If 8-bit MMIO register operations are not supported, then ASSERT().
 398
 399   @param  Address The MMIO register to read.
 400
 401   @return The value read.
 402
 403 **/
 404 UINT8
 405 EFIAPI
 406 MmioRead8 (
 407   IN      UINTN                     Address
 408   )
 409 {
 410   UINT8                             Value;
 411   BOOLEAN                           Flag;
 412
 413   Flag = FilterBeforeMmIoRead (FilterWidth8, Address, &Value);
 414   if (Flag) {
 415     Value = *(volatile UINT8*)Address;
 416   }
 417   FilterAfterMmIoRead (FilterWidth8, Address, &Value);
 418
 419   return Value;
 420 }
 421
 422 /**
 423   Writes an 8-bit MMIO register.
 424
 425   Writes the 8-bit MMIO register specified by Address with the value specified
 426   by Value and returns Value. This function must guarantee that all MMIO read
 427   and write operations are serialized.
 428
 429   If 8-bit MMIO register operations are not supported, then ASSERT().
 430
 431   @param  Address The MMIO register to write.
 432   @param  Value   The value to write to the MMIO register.
 433
 434 **/
 435 UINT8
 436 EFIAPI
 437 MmioWrite8 (
 438   IN      UINTN                     Address,
 439   IN      UINT8                     Value
 440   )
 441 {
 442   BOOLEAN                           Flag;
 443
 444   Flag = FilterBeforeMmIoWrite (FilterWidth8, Address, &Value);
 445   if (Flag) {
 446     *(volatile UINT8*)Address = Value;
 447   }
 448   FilterAfterMmIoWrite (FilterWidth8, Address, &Value);
 449
 450   return Value;
 451 }
 452
 453 /**
 454   Reads a 16-bit MMIO register.
 455
 456   Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
 457   returned. This function must guarantee that all MMIO read and write
 458   operations are serialized.
 459
 460   If 16-bit MMIO register operations are not supported, then ASSERT().
 461
 462   @param  Address The MMIO register to read.
 463
 464   @return The value read.
 465
 466 **/
 467 UINT16
 468 EFIAPI
 469 MmioRead16 (
 470   IN      UINTN                     Address
 471   )
 472 {
 473   UINT16                            Value;
 474   BOOLEAN                           Flag;
 475
 476   ASSERT ((Address & 1) == 0);
 477
 478   Flag = FilterBeforeMmIoRead (FilterWidth16, Address, &Value);
 479   if (Flag) {
 480     Value = *(volatile UINT16*)Address;
 481   }
 482   FilterAfterMmIoRead (FilterWidth16, Address, &Value);
 483
 484   return Value;
 485 }
 486
 487 /**
 488   Writes a 16-bit MMIO register.
 489
 490   Writes the 16-bit MMIO register specified by Address with the value specified
 491   by Value and returns Value. This function must guarantee that all MMIO read
 492   and write operations are serialized.
 493
 494   If 16-bit MMIO register operations are not supported, then ASSERT().
 495
 496   @param  Address The MMIO register to write.
 497   @param  Value   The value to write to the MMIO register.
 498
 499 **/
 500 UINT16
 501 EFIAPI
 502 MmioWrite16 (
 503   IN      UINTN                     Address,
 504   IN      UINT16                    Value
 505   )
 506 {
 507   BOOLEAN                           Flag;
 508
 509   ASSERT ((Address & 1) == 0);
 510
 511   Flag = FilterBeforeMmIoWrite (FilterWidth16, Address, &Value);
 512   if (Flag) {
 513     *(volatile UINT16*)Address = Value;
 514   }
 515   FilterAfterMmIoWrite (FilterWidth16, Address, &Value);
 516
 517   return Value;
 518 }
 519
 520 /**
 521   Reads a 32-bit MMIO register.
 522
 523   Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
 524   returned. This function must guarantee that all MMIO read and write
 525   operations are serialized.
 526
 527   If 32-bit MMIO register operations are not supported, then ASSERT().
 528
 529   @param  Address The MMIO register to read.
 530
 531   @return The value read.
 532
 533 **/
 534 UINT32
 535 EFIAPI
 536 MmioRead32 (
 537   IN      UINTN                     Address
 538   )
 539 {
 540   UINT32                            Value;
 541   BOOLEAN                           Flag;
 542
 543   ASSERT ((Address & 3) == 0);
 544
 545   Flag = FilterBeforeMmIoRead (FilterWidth32, Address, &Value);
 546   if (Flag) {
 547     Value = *(volatile UINT32*)Address;
 548   }
 549   FilterAfterMmIoRead (FilterWidth32, Address, &Value);
 550
 551   return Value;
 552 }
 553
 554 /**
 555   Writes a 32-bit MMIO register.
 556
 557   Writes the 32-bit MMIO register specified by Address with the value specified
 558   by Value and returns Value. This function must guarantee that all MMIO read
 559   and write operations are serialized.
 560
 561   If 32-bit MMIO register operations are not supported, then ASSERT().
 562
 563   @param  Address The MMIO register to write.
 564   @param  Value   The value to write to the MMIO register.
 565
 566 **/
 567 UINT32
 568 EFIAPI
 569 MmioWrite32 (
 570   IN      UINTN                     Address,
 571   IN      UINT32                    Value
 572   )
 573 {
 574   BOOLEAN                           Flag;
 575
 576   ASSERT ((Address & 3) == 0);
 577
 578   Flag = FilterBeforeMmIoWrite (FilterWidth32, Address, &Value);
 579   if (Flag) {
 580   *(volatile UINT32*)Address = Value;
 581   }
 582   FilterAfterMmIoWrite (FilterWidth32, Address, &Value);
 583
 584   return Value;
 585 }
 586
 587 /**
 588   Reads a 64-bit MMIO register.
 589
 590   Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
 591   returned. This function must guarantee that all MMIO read and write
 592   operations are serialized.
 593
 594   If 64-bit MMIO register operations are not supported, then ASSERT().
 595
 596   @param  Address The MMIO register to read.
 597
 598   @return The value read.
 599
 600 **/
 601 UINT64
 602 EFIAPI
 603 MmioRead64 (
 604   IN      UINTN                     Address
 605   )
 606 {
 607   UINT64                            Value;
 608   BOOLEAN                           Flag;
 609
 610   ASSERT ((Address & 7) == 0);
 611
 612   Flag = FilterBeforeMmIoRead (FilterWidth64, Address, &Value);
 613   if (Flag) {
 614     Value = *(volatile UINT64*)Address;
 615   }
 616   FilterAfterMmIoRead (FilterWidth64, Address, &Value);
 617
 618   return Value;
 619 }
 620
 621 /**
 622   Writes a 64-bit MMIO register.
 623
 624   Writes the 64-bit MMIO register specified by Address with the value specified
 625   by Value and returns Value. This function must guarantee that all MMIO read
 626   and write operations are serialized.
 627
 628   If 64-bit MMIO register operations are not supported, then ASSERT().
 629
 630   @param  Address The MMIO register to write.
 631   @param  Value   The value to write to the MMIO register.
 632
 633 **/
 634 UINT64
 635 EFIAPI
 636 MmioWrite64 (
 637   IN      UINTN                     Address,
 638   IN      UINT64                    Value
 639   )
 640 {
 641   BOOLEAN                           Flag;
 642
 643   ASSERT ((Address & 7) == 0);
 644
 645   Flag = FilterBeforeMmIoWrite (FilterWidth64, Address, &Value);
 646   if (Flag) {
 647     *(volatile UINT64*)Address = Value;
 648   }
 649   FilterAfterMmIoWrite (FilterWidth64, Address, &Value);
 650
 651   return Value;
 652 }
 653