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 - 2018, 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
 412   Value = *(volatile UINT8*)Address;
 413   return Value;
 414 }
 415
 416 /**
 417   Writes an 8-bit MMIO register.
 418
 419   Writes the 8-bit MMIO register specified by Address with the value specified
 420   by Value and returns Value. This function must guarantee that all MMIO read
 421   and write operations are serialized.
 422
 423   If 8-bit MMIO register operations are not supported, then ASSERT().
 424
 425   @param  Address The MMIO register to write.
 426   @param  Value   The value to write to the MMIO register.
 427
 428 **/
 429 UINT8
 430 EFIAPI
 431 MmioWrite8 (
 432   IN      UINTN                     Address,
 433   IN      UINT8                     Value
 434   )
 435 {
 436   *(volatile UINT8*)Address = Value;
 437   return Value;
 438 }
 439
 440 /**
 441   Reads a 16-bit MMIO register.
 442
 443   Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
 444   returned. This function must guarantee that all MMIO read and write
 445   operations are serialized.
 446
 447   If 16-bit MMIO register operations are not supported, then ASSERT().
 448
 449   @param  Address The MMIO register to read.
 450
 451   @return The value read.
 452
 453 **/
 454 UINT16
 455 EFIAPI
 456 MmioRead16 (
 457   IN      UINTN                     Address
 458   )
 459 {
 460   UINT16                            Value;
 461
 462   ASSERT ((Address & 1) == 0);
 463   Value = *(volatile UINT16*)Address;
 464   return Value;
 465 }
 466
 467 /**
 468   Writes a 16-bit MMIO register.
 469
 470   Writes the 16-bit MMIO register specified by Address with the value specified
 471   by Value and returns Value. This function must guarantee that all MMIO read
 472   and write operations are serialized.
 473
 474   If 16-bit MMIO register operations are not supported, then ASSERT().
 475
 476   @param  Address The MMIO register to write.
 477   @param  Value   The value to write to the MMIO register.
 478
 479 **/
 480 UINT16
 481 EFIAPI
 482 MmioWrite16 (
 483   IN      UINTN                     Address,
 484   IN      UINT16                    Value
 485   )
 486 {
 487   ASSERT ((Address & 1) == 0);
 488   *(volatile UINT16*)Address = Value;
 489   return Value;
 490 }
 491
 492 /**
 493   Reads a 32-bit MMIO register.
 494
 495   Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
 496   returned. This function must guarantee that all MMIO read and write
 497   operations are serialized.
 498
 499   If 32-bit MMIO register operations are not supported, then ASSERT().
 500
 501   @param  Address The MMIO register to read.
 502
 503   @return The value read.
 504
 505 **/
 506 UINT32
 507 EFIAPI
 508 MmioRead32 (
 509   IN      UINTN                     Address
 510   )
 511 {
 512   UINT32                            Value;
 513
 514   ASSERT ((Address & 3) == 0);
 515   Value = *(volatile UINT32*)Address;
 516   return Value;
 517 }
 518
 519 /**
 520   Writes a 32-bit MMIO register.
 521
 522   Writes the 32-bit MMIO register specified by Address with the value specified
 523   by Value and returns Value. This function must guarantee that all MMIO read
 524   and write operations are serialized.
 525
 526   If 32-bit MMIO register operations are not supported, then ASSERT().
 527
 528   @param  Address The MMIO register to write.
 529   @param  Value   The value to write to the MMIO register.
 530
 531 **/
 532 UINT32
 533 EFIAPI
 534 MmioWrite32 (
 535   IN      UINTN                     Address,
 536   IN      UINT32                    Value
 537   )
 538 {
 539   ASSERT ((Address & 3) == 0);
 540   *(volatile UINT32*)Address = Value;
 541   return Value;
 542 }
 543
 544 /**
 545   Reads a 64-bit MMIO register.
 546
 547   Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
 548   returned. This function must guarantee that all MMIO read and write
 549   operations are serialized.
 550
 551   If 64-bit MMIO register operations are not supported, then ASSERT().
 552
 553   @param  Address The MMIO register to read.
 554
 555   @return The value read.
 556
 557 **/
 558 UINT64
 559 EFIAPI
 560 MmioRead64 (
 561   IN      UINTN                     Address
 562   )
 563 {
 564   UINT64                            Value;
 565
 566   ASSERT ((Address & 7) == 0);
 567   Value = *(volatile UINT64*)Address;
 568   return Value;
 569 }
 570
 571 /**
 572   Writes a 64-bit MMIO register.
 573
 574   Writes the 64-bit MMIO register specified by Address with the value specified
 575   by Value and returns Value. This function must guarantee that all MMIO read
 576   and write operations are serialized.
 577
 578   If 64-bit MMIO register operations are not supported, then ASSERT().
 579
 580   @param  Address The MMIO register to write.
 581   @param  Value   The value to write to the MMIO register.
 582
 583 **/
 584 UINT64
 585 EFIAPI
 586 MmioWrite64 (
 587   IN      UINTN                     Address,
 588   IN      UINT64                    Value
 589   )
 590 {
 591   ASSERT ((Address & 7) == 0);
 592   *(volatile UINT64*)Address = Value;
 593   return Value;
 594 }
 595