IntelFrameworkModulePkg/Bus/Isa/IsaIoDxe/IsaIo.c

   1 /** @file
   2   The implementation for EFI_ISA_IO_PROTOCOL.
   3
   4 Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
   5 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 **/
  14
  15 #include "IsaIo.h"
  16
  17 //
  18 // Module Variables
  19 //
  20 EFI_ISA_IO_PROTOCOL mIsaIoInterface = {
  21   {
  22     IsaIoMemRead,
  23     IsaIoMemWrite
  24   },
  25   {
  26     IsaIoIoRead,
  27     IsaIoIoWrite
  28   },
  29   IsaIoCopyMem,
  30   IsaIoMap,
  31   IsaIoUnmap,
  32   IsaIoAllocateBuffer,
  33   IsaIoFreeBuffer,
  34   IsaIoFlush,
  35   NULL,
  36   0,
  37   NULL
  38 };
  39
  40 EFI_ISA_DMA_REGISTERS  mDmaRegisters[8] = {
  41   {
  42     0x00,
  43     0x87,
  44     0x01
  45   },
  46   {
  47     0x02,
  48     0x83,
  49     0x03
  50   },
  51   {
  52     0x04,
  53     0x81,
  54     0x05
  55   },
  56   {
  57     0x06,
  58     0x82,
  59     0x07
  60   },
  61   {
  62     0x00,
  63     0x00,
  64     0x00
  65   },  // Channel 4 is invalid
  66   {
  67     0xC4,
  68     0x8B,
  69     0xC6
  70   },
  71   {
  72     0xC8,
  73     0x89,
  74     0xCA
  75   },
  76   {
  77     0xCC,
  78     0x8A,
  79     0xCE
  80   },
  81 };
  82
  83 /**
  84   Verifies access to an ISA device
  85
  86   @param[in] IsaIoDevice         The ISA device to be verified.
  87   @param[in] Type                The Access type. The input must be either IsaAccessTypeMem or IsaAccessTypeIo.
  88   @param[in] Width               The width of the memory operation.
  89   @param[in] Count               The number of memory operations to perform.
  90   @param[in] Offset              The offset in ISA memory space to start the memory operation.
  91
  92   @retval EFI_SUCCESS            Verify success.
  93   @retval EFI_INVALID_PARAMETER  One of the parameters has an invalid value.
  94   @retval EFI_UNSUPPORTED        The device ont support the access type.
  95 **/
  96 EFI_STATUS
  97 IsaIoVerifyAccess (
  98   IN ISA_IO_DEVICE              *IsaIoDevice,
  99   IN ISA_ACCESS_TYPE            Type,
 100   IN EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 101   IN UINTN                      Count,
 102   IN UINT32                     Offset
 103   )
 104 {
 105   EFI_ISA_ACPI_RESOURCE *Item;
 106   EFI_STATUS            Status;
 107
 108   if ((UINT32)Width >= EfiIsaIoWidthMaximum ||
 109       Width == EfiIsaIoWidthReserved ||
 110       Width == EfiIsaIoWidthFifoReserved ||
 111       Width == EfiIsaIoWidthFillReserved
 112       ) {
 113     return EFI_INVALID_PARAMETER;
 114   }
 115
 116   //
 117   // If Width is EfiIsaIoWidthFifoUintX then convert to EfiIsaIoWidthUintX
 118   // If Width is EfiIsaIoWidthFillUintX then convert to EfiIsaIoWidthUintX
 119   //
 120   if (Width >= EfiIsaIoWidthFifoUint8 && Width < EfiIsaIoWidthFifoReserved) {
 121     Count = 1;
 122   }
 123
 124   Width = (EFI_ISA_IO_PROTOCOL_WIDTH) (Width & 0x03);
 125
 126   Status  = EFI_UNSUPPORTED;
 127   Item    = IsaIoDevice->IsaIo.ResourceList->ResourceItem;
 128   while (Item->Type != EfiIsaAcpiResourceEndOfList) {
 129     if ((Type == IsaAccessTypeMem && Item->Type == EfiIsaAcpiResourceMemory) ||
 130         (Type == IsaAccessTypeIo && Item->Type == EfiIsaAcpiResourceIo)) {
 131       if (Offset >= Item->StartRange && (Offset + Count * (UINT32)(1 << Width)) - 1 <= Item->EndRange) {
 132         return EFI_SUCCESS;
 133       }
 134
 135       if (Offset >= Item->StartRange && Offset <= Item->EndRange) {
 136         Status = EFI_INVALID_PARAMETER;
 137       }
 138     }
 139
 140     Item++;
 141   }
 142
 143   return Status;
 144 }
 145
 146 /**
 147   Convert the IO Information in ACPI descriptor to IO ISA Attribute.
 148
 149   @param[in] Information   The IO Information in ACPI descriptor
 150
 151   @return UINT32           The IO ISA Attribute
 152 **/
 153 UINT32
 154 IsaIoAttribute (
 155   IN UINT8                            Information
 156   )
 157 {
 158   UINT32             Attribute;
 159
 160   Attribute = 0;
 161
 162   switch (Information & EFI_ACPI_IO_DECODE_MASK) {
 163     case EFI_ACPI_IO_DECODE_16_BIT:
 164       Attribute |= EFI_ISA_ACPI_IO_DECODE_16_BITS;
 165       break;
 166
 167     case EFI_ACPI_IO_DECODE_10_BIT:
 168       Attribute |= EFI_ISA_ACPI_IO_DECODE_10_BITS;
 169       break;
 170   }
 171
 172   return Attribute;
 173 }
 174
 175 /**
 176   Convert the IRQ Information in ACPI descriptor to IRQ ISA Attribute.
 177
 178   @param[in] Information   The IRQ Information in ACPI descriptor
 179
 180   @return UINT32           The IRQ ISA Attribute
 181 **/
 182 UINT32
 183 IsaIrqAttribute (
 184   IN UINT8                            Information
 185   )
 186 {
 187   UINT32             Attribute;
 188
 189   Attribute = 0;
 190
 191   if ((Information & EFI_ACPI_IRQ_POLARITY_MASK) == EFI_ACPI_IRQ_HIGH_TRUE) {
 192     if ((Information & EFI_ACPI_IRQ_MODE) == EFI_ACPI_IRQ_LEVEL_TRIGGERED) {
 193       Attribute = EFI_ISA_ACPI_IRQ_TYPE_HIGH_TRUE_LEVEL_SENSITIVE;
 194     } else {
 195       Attribute = EFI_ISA_ACPI_IRQ_TYPE_HIGH_TRUE_EDGE_SENSITIVE;
 196     }
 197   } else {
 198     if ((Information & EFI_ACPI_IRQ_MODE) == EFI_ACPI_IRQ_LEVEL_TRIGGERED) {
 199       Attribute = EFI_ISA_ACPI_IRQ_TYPE_LOW_TRUE_LEVEL_SENSITIVE;
 200     } else {
 201       Attribute = EFI_ISA_ACPI_IRQ_TYPE_LOW_TRUE_EDGE_SENSITIVE;
 202     }
 203   }
 204   return Attribute;
 205 }
 206
 207 /**
 208   Convert the Memory Information in ACPI descriptor to Memory ISA Attribute.
 209
 210   @param[in] Information   The Memory Information in ACPI descriptor
 211
 212   @return UINT32           The Memory ISA Attribute
 213 **/
 214 UINT32
 215 IsaMemoryAttribute (
 216   IN UINT8                            Information
 217   )
 218 {
 219   UINT32             Attribute;
 220
 221   Attribute = 0;
 222
 223   switch (Information & EFI_ACPI_MEMORY_WRITE_STATUS_MASK) {
 224     case EFI_ACPI_MEMORY_WRITABLE:
 225       Attribute |= EFI_ISA_ACPI_MEMORY_WRITEABLE;
 226       break;
 227   }
 228
 229   return Attribute;
 230 }
 231
 232 /**
 233   Convert the DMA Information in ACPI descriptor to DMA ISA Attribute.
 234
 235   @param[in] Information   The DMA Information in ACPI descriptor
 236
 237   @return UINT32           The DMA ISA Attribute
 238 **/
 239 UINT32
 240 IsaDmaAttribute (
 241   IN UINT8                            Information
 242   )
 243 {
 244   UINT32             Attribute;
 245
 246   Attribute = EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE;
 247
 248   switch (Information & EFI_ACPI_DMA_SPEED_TYPE_MASK) {
 249     case EFI_ACPI_DMA_SPEED_TYPE_COMPATIBILITY:
 250       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_COMPATIBLE;
 251       break;
 252     case EFI_ACPI_DMA_SPEED_TYPE_A:
 253       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_A;
 254       break;
 255     case EFI_ACPI_DMA_SPEED_TYPE_B:
 256       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_B;
 257       break;
 258     case EFI_ACPI_DMA_SPEED_TYPE_F:
 259       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_C;
 260       break;
 261   }
 262
 263   switch (Information & EFI_ACPI_DMA_TRANSFER_TYPE_MASK) {
 264     case EFI_ACPI_DMA_TRANSFER_TYPE_8_BIT:
 265       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8;
 266       break;
 267     case EFI_ACPI_DMA_TRANSFER_TYPE_16_BIT:
 268       Attribute |= EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16;
 269       break;
 270   }
 271
 272   return Attribute;
 273 }
 274
 275 /**
 276   Convert the ACPI resource descriptor to ISA resource descriptor.
 277
 278   @param[in]  AcpiResource          Pointer to the ACPI resource descriptor
 279   @param[out] IsaResource           The optional pointer to the buffer to
 280                                     store the converted ISA resource descriptor
 281
 282   @return     UINTN                 Number of ISA resource descriptor needed
 283 **/
 284 UINTN
 285 AcpiResourceToIsaResource (
 286   IN  ACPI_RESOURCE_HEADER_PTR        AcpiResource,
 287   OUT EFI_ISA_ACPI_RESOURCE           *IsaResource   OPTIONAL
 288   )
 289 {
 290   UINT32                                        Index;
 291   UINTN                                         Count;
 292   UINT32                                        LastIndex;
 293   EFI_ACPI_IO_PORT_DESCRIPTOR                   *Io;
 294   EFI_ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR    *FixedIo;
 295   EFI_ACPI_IRQ_DESCRIPTOR                       *Irq;
 296   EFI_ACPI_DMA_DESCRIPTOR                       *Dma;
 297   EFI_ACPI_32_BIT_MEMORY_RANGE_DESCRIPTOR       *Memory;
 298   EFI_ACPI_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR *FixedMemory;
 299
 300   Count     = 0;
 301   LastIndex = 0;
 302
 303   switch (AcpiResource.SmallHeader->Byte) {
 304     case ACPI_DMA_DESCRIPTOR:
 305       Dma = (EFI_ACPI_DMA_DESCRIPTOR *) AcpiResource.SmallHeader;
 306       for (Index = 0; Index < sizeof (Dma->ChannelMask) * 8; Index++) {
 307         if (Dma->ChannelMask & (1 << Index)) {
 308           if ((Count > 0) && (LastIndex + 1 == Index)) {
 309             if (IsaResource != NULL) {
 310               IsaResource[Count - 1].EndRange ++;
 311             }
 312           } else {
 313             if (IsaResource != NULL) {
 314               IsaResource[Count].Type       = EfiIsaAcpiResourceDma;
 315               IsaResource[Count].Attribute  = IsaDmaAttribute (Dma->Information);
 316               IsaResource[Count].StartRange = Index;
 317               IsaResource[Count].EndRange   = Index;
 318             }
 319             Count ++;
 320           }
 321
 322           LastIndex = Index;
 323         }
 324       }
 325       break;
 326
 327     case ACPI_IO_PORT_DESCRIPTOR:
 328       Io = (EFI_ACPI_IO_PORT_DESCRIPTOR *) AcpiResource.SmallHeader;
 329       if (Io->Length != 0) {
 330         if (IsaResource != NULL) {
 331           IsaResource[Count].Type       = EfiIsaAcpiResourceIo;
 332           IsaResource[Count].Attribute  = IsaIoAttribute (Io->Information);
 333           IsaResource[Count].StartRange = Io->BaseAddressMin;
 334           IsaResource[Count].EndRange   = Io->BaseAddressMin + Io->Length - 1;
 335         }
 336         Count ++;
 337       }
 338       break;
 339
 340     case ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR:
 341       FixedIo = (EFI_ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR *) AcpiResource.SmallHeader;
 342       if (FixedIo->Length != 0) {
 343         if (IsaResource != NULL) {
 344           IsaResource[Count].Type       = EfiIsaAcpiResourceIo;
 345           IsaResource[Count].Attribute  = EFI_ISA_ACPI_IO_DECODE_10_BITS;
 346           IsaResource[Count].StartRange = FixedIo->BaseAddress;
 347           IsaResource[Count].EndRange   = FixedIo->BaseAddress + FixedIo->Length - 1;
 348         }
 349         Count ++;
 350       }
 351       break;
 352
 353     case ACPI_IRQ_DESCRIPTOR:
 354     case ACPI_IRQ_NOFLAG_DESCRIPTOR:
 355       Irq = (EFI_ACPI_IRQ_DESCRIPTOR *) AcpiResource.SmallHeader;
 356       for (Index = 0; Index < sizeof (Irq->Mask) * 8; Index++) {
 357         if (Irq->Mask & (1 << Index)) {
 358           if ((Count > 0) && (LastIndex + 1 == Index)) {
 359             if (IsaResource != NULL) {
 360               IsaResource[Count - 1].EndRange ++;
 361             }
 362           } else {
 363             if (IsaResource != NULL) {
 364               IsaResource[Count].Type       = EfiIsaAcpiResourceInterrupt;
 365               if (AcpiResource.SmallHeader->Byte == ACPI_IRQ_DESCRIPTOR) {
 366                 IsaResource[Count].Attribute = IsaIrqAttribute (Irq->Information);
 367               } else {
 368                 IsaResource[Count].Attribute  = EFI_ISA_ACPI_IRQ_TYPE_HIGH_TRUE_EDGE_SENSITIVE;
 369               }
 370               IsaResource[Count].StartRange = Index;
 371               IsaResource[Count].EndRange   = Index;
 372             }
 373             Count++;
 374           }
 375
 376           LastIndex = Index;
 377         }
 378       }
 379       break;
 380
 381     case ACPI_32_BIT_MEMORY_RANGE_DESCRIPTOR:
 382       Memory = (EFI_ACPI_32_BIT_MEMORY_RANGE_DESCRIPTOR *) AcpiResource.LargeHeader;
 383       if (Memory->Length != 0) {
 384         if (IsaResource != NULL) {
 385           IsaResource[Count].Type       = EfiIsaAcpiResourceMemory;
 386           IsaResource[Count].Attribute  = IsaMemoryAttribute (Memory->Information);
 387           IsaResource[Count].StartRange = Memory->BaseAddressMin;
 388           IsaResource[Count].EndRange   = Memory->BaseAddressMin + Memory->Length - 1;
 389         }
 390         Count ++;
 391       }
 392       break;
 393
 394     case ACPI_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR:
 395       FixedMemory = (EFI_ACPI_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR *) AcpiResource.LargeHeader;
 396       if (FixedMemory->Length != 0) {
 397         if (IsaResource != NULL) {
 398           IsaResource[Count].Type       = EfiIsaAcpiResourceMemory;
 399           IsaResource[Count].Attribute  = IsaMemoryAttribute (FixedMemory->Information);
 400           IsaResource[Count].StartRange = FixedMemory->BaseAddress;
 401           IsaResource[Count].EndRange   = FixedMemory->BaseAddress + FixedMemory->Length - 1;
 402         }
 403         Count ++;
 404       }
 405       break;
 406
 407     case ACPI_END_TAG_DESCRIPTOR:
 408       if (IsaResource != NULL) {
 409         IsaResource[Count].Type       = EfiIsaAcpiResourceEndOfList;
 410         IsaResource[Count].Attribute  = 0;
 411         IsaResource[Count].StartRange = 0;
 412         IsaResource[Count].EndRange   = 0;
 413       }
 414       Count ++;
 415       break;
 416   }
 417
 418   return Count;
 419 }
 420
 421 /**
 422   Initializes an ISA I/O Instance
 423
 424   @param[in] IsaIoDevice            The isa device to be initialized.
 425   @param[in] DevicePath             The device path of the isa device.
 426   @param[in] Resources              The ACPI resource list.
 427
 428 **/
 429 VOID
 430 InitializeIsaIoInstance (
 431   IN ISA_IO_DEVICE               *IsaIoDevice,
 432   IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath,
 433   IN ACPI_RESOURCE_HEADER_PTR    Resources
 434   )
 435 {
 436   UINTN                                       Index;
 437   ACPI_HID_DEVICE_PATH                        *AcpiNode;
 438   ACPI_RESOURCE_HEADER_PTR                    ResourcePtr;
 439
 440   //
 441   // Use the ISA IO Protocol structure template to initialize the ISA IO instance
 442   //
 443   CopyMem (
 444     &IsaIoDevice->IsaIo,
 445     &mIsaIoInterface,
 446     sizeof (EFI_ISA_IO_PROTOCOL)
 447     );
 448
 449   //
 450   // Count the resources including the ACPI End Tag
 451   //
 452   ResourcePtr = Resources;
 453   Index       = 0;
 454   while (ResourcePtr.SmallHeader->Byte != ACPI_END_TAG_DESCRIPTOR) {
 455
 456     Index += AcpiResourceToIsaResource (ResourcePtr, NULL);
 457
 458     if (ResourcePtr.SmallHeader->Bits.Type == 0) {
 459       ResourcePtr.SmallHeader = (ACPI_SMALL_RESOURCE_HEADER *) ((UINT8 *) ResourcePtr.SmallHeader
 460                               + ResourcePtr.SmallHeader->Bits.Length
 461                               + sizeof (*ResourcePtr.SmallHeader));
 462     } else {
 463       ResourcePtr.LargeHeader = (ACPI_LARGE_RESOURCE_HEADER *) ((UINT8 *) ResourcePtr.LargeHeader
 464                               + ResourcePtr.LargeHeader->Length
 465                               + sizeof (*ResourcePtr.LargeHeader));
 466     }
 467
 468   }
 469   //
 470   // Get the Isa Resource count for ACPI End Tag
 471   //
 472   Index += AcpiResourceToIsaResource (ResourcePtr, NULL);
 473
 474   //
 475   // Initialize the ResourceList
 476   //
 477   IsaIoDevice->IsaIo.ResourceList = AllocatePool (sizeof (EFI_ISA_ACPI_RESOURCE_LIST) + Index * sizeof (EFI_ISA_ACPI_RESOURCE));
 478   ASSERT (IsaIoDevice->IsaIo.ResourceList != NULL);
 479   IsaIoDevice->IsaIo.ResourceList->ResourceItem = (EFI_ISA_ACPI_RESOURCE *) (IsaIoDevice->IsaIo.ResourceList + 1);
 480
 481   AcpiNode = (ACPI_HID_DEVICE_PATH *) ((UINT8 *) DevicePath + GetDevicePathSize (DevicePath) - END_DEVICE_PATH_LENGTH - sizeof (ACPI_HID_DEVICE_PATH));
 482   IsaIoDevice->IsaIo.ResourceList->Device.HID = AcpiNode->HID;
 483   IsaIoDevice->IsaIo.ResourceList->Device.UID = AcpiNode->UID;
 484
 485   ResourcePtr = Resources;
 486   Index       = 0;
 487   while (ResourcePtr.SmallHeader->Byte != ACPI_END_TAG_DESCRIPTOR) {
 488
 489     Index += AcpiResourceToIsaResource (ResourcePtr, &IsaIoDevice->IsaIo.ResourceList->ResourceItem[Index]);
 490
 491     if (ResourcePtr.SmallHeader->Bits.Type == 0) {
 492       ResourcePtr.SmallHeader = (ACPI_SMALL_RESOURCE_HEADER *) ((UINT8 *) ResourcePtr.SmallHeader
 493                               + ResourcePtr.SmallHeader->Bits.Length
 494                               + sizeof (*ResourcePtr.SmallHeader));
 495     } else {
 496       ResourcePtr.LargeHeader = (ACPI_LARGE_RESOURCE_HEADER *) ((UINT8 *) ResourcePtr.LargeHeader
 497                               + ResourcePtr.LargeHeader->Length
 498                               + sizeof (*ResourcePtr.LargeHeader));
 499     }
 500   }
 501
 502   //
 503   // Convert the ACPI End Tag
 504   //
 505   AcpiResourceToIsaResource (ResourcePtr, &IsaIoDevice->IsaIo.ResourceList->ResourceItem[Index]);
 506 }
 507
 508 /**
 509   Performs an ISA I/O Read Cycle
 510
 511   @param[in]  This              A pointer to the EFI_ISA_IO_PROTOCOL instance.
 512   @param[in]  Width             Specifies the width of the I/O operation.
 513   @param[in]  Offset            The offset in ISA I/O space to start the I/O operation.
 514   @param[in]  Count             The number of I/O operations to perform.
 515   @param[out] Buffer            The destination buffer to store the results
 516
 517   @retval EFI_SUCCESS           The data was read from the device sucessfully.
 518   @retval EFI_UNSUPPORTED       The Offset is not valid for this device.
 519   @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
 520   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
 521 **/
 522 EFI_STATUS
 523 EFIAPI
 524 IsaIoIoRead (
 525   IN  EFI_ISA_IO_PROTOCOL        *This,
 526   IN  EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 527   IN  UINT32                     Offset,
 528   IN  UINTN                      Count,
 529   OUT VOID                       *Buffer
 530   )
 531 {
 532   EFI_STATUS    Status;
 533   ISA_IO_DEVICE *IsaIoDevice;
 534
 535   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 536
 537   //
 538   // Verify Isa IO Access
 539   //
 540   Status = IsaIoVerifyAccess (
 541              IsaIoDevice,
 542              IsaAccessTypeIo,
 543              Width,
 544              Count,
 545              Offset
 546              );
 547   if (EFI_ERROR (Status)) {
 548     return Status;
 549   }
 550
 551   Status = IsaIoDevice->PciIo->Io.Read (
 552                                     IsaIoDevice->PciIo,
 553                                     (EFI_PCI_IO_PROTOCOL_WIDTH) Width,
 554                                     EFI_PCI_IO_PASS_THROUGH_BAR,
 555                                     Offset,
 556                                     Count,
 557                                     Buffer
 558                                     );
 559
 560   if (EFI_ERROR (Status)) {
 561     REPORT_STATUS_CODE (
 562       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 563       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 564       );
 565   }
 566
 567   return Status;
 568 }
 569
 570 /**
 571   Performs an ISA I/O Write Cycle
 572
 573   @param[in] This                A pointer to the EFI_ISA_IO_PROTOCOL instance.
 574   @param[in] Width               Specifies the width of the I/O operation.
 575   @param[in] Offset              The offset in ISA I/O space to start the I/O operation.
 576   @param[in] Count               The number of I/O operations to perform.
 577   @param[in] Buffer              The source buffer to write data from
 578
 579   @retval EFI_SUCCESS            The data was writen to the device sucessfully.
 580   @retval EFI_UNSUPPORTED        The Offset is not valid for this device.
 581   @retval EFI_INVALID_PARAMETER  Width or Count, or both, were invalid.
 582   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 583 **/
 584 EFI_STATUS
 585 EFIAPI
 586 IsaIoIoWrite (
 587   IN EFI_ISA_IO_PROTOCOL        *This,
 588   IN EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 589   IN UINT32                     Offset,
 590   IN UINTN                      Count,
 591   IN VOID                       *Buffer
 592   )
 593 {
 594   EFI_STATUS    Status;
 595   ISA_IO_DEVICE *IsaIoDevice;
 596
 597   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 598
 599   //
 600   // Verify Isa IO Access
 601   //
 602   Status = IsaIoVerifyAccess (
 603              IsaIoDevice,
 604              IsaAccessTypeIo,
 605              Width,
 606              Count,
 607              Offset
 608              );
 609   if (EFI_ERROR (Status)) {
 610     return Status;
 611   }
 612
 613   Status = IsaIoDevice->PciIo->Io.Write (
 614                                     IsaIoDevice->PciIo,
 615                                     (EFI_PCI_IO_PROTOCOL_WIDTH) Width,
 616                                     EFI_PCI_IO_PASS_THROUGH_BAR,
 617                                     Offset,
 618                                     Count,
 619                                     Buffer
 620                                     );
 621
 622   if (EFI_ERROR (Status)) {
 623     REPORT_STATUS_CODE (
 624       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 625       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 626       );
 627   }
 628
 629   return Status;
 630 }
 631
 632 /**
 633   Writes an 8-bit I/O Port
 634
 635   @param[in] This                A pointer to the EFI_ISA_IO_PROTOCOL instance.
 636   @param[in] Offset              The offset in ISA IO space to start the IO operation.
 637   @param[in] Value               The data to write port.
 638
 639   @retval EFI_SUCCESS            Success.
 640   @retval EFI_INVALID_PARAMETER  Parameter is invalid.
 641   @retval EFI_UNSUPPORTED        The address range specified by Offset is not valid.
 642   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 643 **/
 644 EFI_STATUS
 645 WritePort (
 646   IN EFI_ISA_IO_PROTOCOL  *This,
 647   IN UINT32               Offset,
 648   IN UINT8                Value
 649   )
 650 {
 651   EFI_STATUS    Status;
 652   ISA_IO_DEVICE *IsaIoDevice;
 653
 654   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 655
 656   Status = IsaIoDevice->PciIo->Io.Write (
 657                                     IsaIoDevice->PciIo,
 658                                     EfiPciIoWidthUint8,
 659                                     EFI_PCI_IO_PASS_THROUGH_BAR,
 660                                     Offset,
 661                                     1,
 662                                     &Value
 663                                     );
 664   if (EFI_ERROR (Status)) {
 665     REPORT_STATUS_CODE (
 666       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 667       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 668       );
 669     return Status;
 670   }
 671
 672   //
 673   // Wait for 50 microseconds to take affect.
 674   //
 675   gBS->Stall (50);
 676
 677   return EFI_SUCCESS;
 678 }
 679
 680 /**
 681   Writes I/O operation base address and count number to a 8 bit I/O Port.
 682
 683   @param[in] This                A pointer to the EFI_ISA_IO_PROTOCOL instance.
 684   @param[in] AddrOffset          The address' offset.
 685   @param[in] PageOffset          The page's offest.
 686   @param[in] CountOffset         The count's offset.
 687   @param[in] BaseAddress         The base address.
 688   @param[in] Count               The number of I/O operations to perform.
 689
 690   @retval EFI_SUCCESS            Success.
 691   @retval EFI_INVALID_PARAMETER  Parameter is invalid.
 692   @retval EFI_UNSUPPORTED        The address range specified by these Offsets and Count is not valid.
 693   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 694 **/
 695 EFI_STATUS
 696 WriteDmaPort (
 697   IN EFI_ISA_IO_PROTOCOL  *This,
 698   IN UINT32               AddrOffset,
 699   IN UINT32               PageOffset,
 700   IN UINT32               CountOffset,
 701   IN UINT32               BaseAddress,
 702   IN UINT16               Count
 703   )
 704 {
 705   EFI_STATUS  Status;
 706
 707   Status = WritePort (This, AddrOffset, (UINT8) (BaseAddress & 0xff));
 708   if (EFI_ERROR (Status)) {
 709     return Status;
 710   }
 711
 712   Status = WritePort (This, AddrOffset, (UINT8) ((BaseAddress >> 8) & 0xff));
 713   if (EFI_ERROR (Status)) {
 714     return Status;
 715   }
 716
 717   Status = WritePort (This, PageOffset, (UINT8) ((BaseAddress >> 16) & 0xff));
 718   if (EFI_ERROR (Status)) {
 719     return Status;
 720   }
 721
 722   Status = WritePort (This, CountOffset, (UINT8) (Count & 0xff));
 723   if (EFI_ERROR (Status)) {
 724     return Status;
 725   }
 726
 727   Status = WritePort (This, CountOffset, (UINT8) ((Count >> 8) & 0xff));
 728   return Status;
 729 }
 730
 731 /**
 732   Unmaps a memory region for DMA
 733
 734   @param[in] This           A pointer to the EFI_ISA_IO_PROTOCOL instance.
 735   @param[in] Mapping        The mapping value returned from EFI_ISA_IO.Map().
 736
 737   @retval EFI_SUCCESS       The range was unmapped.
 738   @retval EFI_DEVICE_ERROR  The data was not committed to the target system memory.
 739 **/
 740 EFI_STATUS
 741 EFIAPI
 742 IsaIoUnmap (
 743   IN EFI_ISA_IO_PROTOCOL  *This,
 744   IN VOID                 *Mapping
 745   )
 746 {
 747   ISA_MAP_INFO  *IsaMapInfo;
 748
 749   //
 750   // Check if DMA is supported.
 751   //
 752   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) {
 753     return EFI_UNSUPPORTED;
 754   }
 755
 756   //
 757   // See if the Map() operation associated with this Unmap() required a mapping
 758   // buffer.If a mapping buffer was not required, then this function simply
 759   // returns EFI_SUCCESS.
 760   //
 761   if (Mapping != NULL) {
 762     //
 763     // Get the MAP_INFO structure from Mapping
 764     //
 765     IsaMapInfo = (ISA_MAP_INFO *) Mapping;
 766
 767     //
 768     // If this is a write operation from the Agent's point of view,
 769     // then copy the contents of the mapped buffer into the real buffer
 770     // so the processor can read the contents of the real buffer.
 771     //
 772     if (IsaMapInfo->Operation == EfiIsaIoOperationBusMasterWrite) {
 773       CopyMem (
 774         (VOID *) (UINTN) IsaMapInfo->HostAddress,
 775         (VOID *) (UINTN) IsaMapInfo->MappedHostAddress,
 776         IsaMapInfo->NumberOfBytes
 777         );
 778     }
 779     //
 780     // Free the mapped buffer and the MAP_INFO structure.
 781     //
 782     gBS->FreePages (IsaMapInfo->MappedHostAddress, IsaMapInfo->NumberOfPages);
 783     FreePool (IsaMapInfo);
 784   }
 785
 786   return EFI_SUCCESS;
 787 }
 788
 789 /**
 790   Flushes any posted write data to the system memory.
 791
 792   @param[in] This             A pointer to the EFI_ISA_IO_PROTOCOL instance.
 793
 794   @retval  EFI_SUCCESS        The buffers were flushed.
 795   @retval  EFI_DEVICE_ERROR   The buffers were not flushed due to a hardware error.
 796 **/
 797 EFI_STATUS
 798 EFIAPI
 799 IsaIoFlush (
 800   IN EFI_ISA_IO_PROTOCOL  *This
 801   )
 802 {
 803   EFI_STATUS    Status;
 804   ISA_IO_DEVICE *IsaIoDevice;
 805
 806   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 807
 808   Status = IsaIoDevice->PciIo->Flush (IsaIoDevice->PciIo);
 809
 810   if (EFI_ERROR (Status)) {
 811     REPORT_STATUS_CODE (
 812       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 813       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 814       );
 815   }
 816
 817   return Status;
 818 }
 819
 820 /**
 821   Performs an ISA Memory Read Cycle
 822
 823   @param[in]  This               A pointer to the EFI_ISA_IO_PROTOCOL instance.
 824   @param[in]  Width              Specifies the width of the memory operation.
 825   @param[in]  Offset             The offset in ISA memory space to start the memory operation.
 826   @param[in]  Count              The number of memory operations to perform.
 827   @param[out] Buffer             The destination buffer to store the results
 828
 829   @retval EFI_SUCCESS            The data was read from the device successfully.
 830   @retval EFI_UNSUPPORTED        The Offset is not valid for this device.
 831   @retval EFI_INVALID_PARAMETER  Width or Count, or both, were invalid.
 832   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 833 **/
 834 EFI_STATUS
 835 EFIAPI
 836 IsaIoMemRead (
 837   IN  EFI_ISA_IO_PROTOCOL        *This,
 838   IN  EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 839   IN  UINT32                     Offset,
 840   IN  UINTN                      Count,
 841   OUT VOID                       *Buffer
 842   )
 843 {
 844   EFI_STATUS    Status;
 845   ISA_IO_DEVICE *IsaIoDevice;
 846
 847   //
 848   // Check if ISA memory is supported.
 849   //
 850   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) {
 851     return EFI_UNSUPPORTED;
 852   }
 853
 854   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 855
 856   //
 857   // Verify the Isa Io Access
 858   //
 859   Status = IsaIoVerifyAccess (
 860              IsaIoDevice,
 861              IsaAccessTypeMem,
 862              Width,
 863              Count,
 864              Offset
 865              );
 866   if (EFI_ERROR (Status)) {
 867     return Status;
 868   }
 869
 870   Status = IsaIoDevice->PciIo->Mem.Read (
 871                                      IsaIoDevice->PciIo,
 872                                      (EFI_PCI_IO_PROTOCOL_WIDTH) Width,
 873                                      EFI_PCI_IO_PASS_THROUGH_BAR,
 874                                      Offset,
 875                                      Count,
 876                                      Buffer
 877                                      );
 878
 879   if (EFI_ERROR (Status)) {
 880     REPORT_STATUS_CODE (
 881       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 882       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 883       );
 884   }
 885
 886   return Status;
 887 }
 888
 889 /**
 890   Performs an ISA Memory Write Cycle
 891
 892   @param[in] This                A pointer to the EFI_ISA_IO_PROTOCOL instance.
 893   @param[in] Width               Specifies the width of the memory operation.
 894   @param[in] Offset              The offset in ISA memory space to start the memory operation.
 895   @param[in] Count               The number of memory operations to perform.
 896   @param[in] Buffer              The source buffer to write data from
 897
 898   @retval EFI_SUCCESS            The data was written to the device sucessfully.
 899   @retval EFI_UNSUPPORTED        The Offset is not valid for this device.
 900   @retval EFI_INVALID_PARAMETER  Width or Count, or both, were invalid.
 901   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 902 **/
 903 EFI_STATUS
 904 EFIAPI
 905 IsaIoMemWrite (
 906   IN EFI_ISA_IO_PROTOCOL        *This,
 907   IN EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 908   IN UINT32                     Offset,
 909   IN UINTN                      Count,
 910   IN VOID                       *Buffer
 911   )
 912 {
 913   EFI_STATUS    Status;
 914   ISA_IO_DEVICE *IsaIoDevice;
 915
 916   //
 917   // Check if ISA memory is supported.
 918   //
 919   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) {
 920     return EFI_UNSUPPORTED;
 921   }
 922
 923   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 924
 925   //
 926   // Verify Isa IO Access
 927   //
 928   Status = IsaIoVerifyAccess (
 929              IsaIoDevice,
 930              IsaAccessTypeMem,
 931              Width,
 932              Count,
 933              Offset
 934              );
 935   if (EFI_ERROR (Status)) {
 936     return Status;
 937   }
 938
 939   Status = IsaIoDevice->PciIo->Mem.Write (
 940                                      IsaIoDevice->PciIo,
 941                                      (EFI_PCI_IO_PROTOCOL_WIDTH) Width,
 942                                      EFI_PCI_IO_PASS_THROUGH_BAR,
 943                                      Offset,
 944                                      Count,
 945                                      Buffer
 946                                      );
 947
 948   if (EFI_ERROR (Status)) {
 949     REPORT_STATUS_CODE (
 950       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 951       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
 952       );
 953   }
 954
 955   return Status;
 956 }
 957
 958 /**
 959   Copy one region of ISA memory space to another region of ISA memory space on the ISA controller.
 960
 961   @param[in]  This               A pointer to the EFI_ISA_IO_PROTOCOL instance.
 962   @param[in]  Width              Specifies the width of the memory copy operation.
 963   @param[in]  DestOffset         The offset of the destination
 964   @param[in]  SrcOffset          The offset of the source
 965   @param[in]  Count              The number of memory copy  operations to perform
 966
 967   @retval EFI_SUCCESS            The data was copied sucessfully.
 968   @retval EFI_UNSUPPORTED        The DestOffset or SrcOffset is not valid for this device.
 969   @retval EFI_INVALID_PARAMETER  Width or Count, or both, were invalid.
 970   @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack of resources.
 971 **/
 972 EFI_STATUS
 973 EFIAPI
 974 IsaIoCopyMem (
 975   IN EFI_ISA_IO_PROTOCOL        *This,
 976   IN EFI_ISA_IO_PROTOCOL_WIDTH  Width,
 977   IN UINT32                     DestOffset,
 978   IN UINT32                     SrcOffset,
 979   IN UINTN                      Count
 980   )
 981 {
 982   EFI_STATUS    Status;
 983   ISA_IO_DEVICE *IsaIoDevice;
 984
 985   //
 986   // Check if ISA memory is supported.
 987   //
 988   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) {
 989     return EFI_UNSUPPORTED;
 990   }
 991
 992   IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This);
 993
 994   //
 995   // Verify Isa IO Access for destination and source
 996   //
 997   Status = IsaIoVerifyAccess (
 998              IsaIoDevice,
 999              IsaAccessTypeMem,
1000              Width,
1001              Count,
1002              DestOffset
1003              );
1004   if (EFI_ERROR (Status)) {
1005     return Status;
1006   }
1007
1008   Status = IsaIoVerifyAccess (
1009              IsaIoDevice,
1010              IsaAccessTypeMem,
1011              Width,
1012              Count,
1013              SrcOffset
1014              );
1015   if (EFI_ERROR (Status)) {
1016     return Status;
1017   }
1018
1019   Status = IsaIoDevice->PciIo->CopyMem (
1020                                  IsaIoDevice->PciIo,
1021                                  (EFI_PCI_IO_PROTOCOL_WIDTH) Width,
1022                                  EFI_PCI_IO_PASS_THROUGH_BAR,
1023                                  DestOffset,
1024                                  EFI_PCI_IO_PASS_THROUGH_BAR,
1025                                  SrcOffset,
1026                                  Count
1027                                  );
1028
1029   if (EFI_ERROR (Status)) {
1030     REPORT_STATUS_CODE (
1031       EFI_ERROR_CODE | EFI_ERROR_MINOR,
1032       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
1033       );
1034   }
1035
1036   return Status;
1037 }
1038
1039 /**
1040   Maps a memory region for DMA, note this implementation
1041   only supports slave read/write operation to save code size.
1042
1043   @param This                    A pointer to the EFI_ISA_IO_PROTOCOL instance.
1044   @param Operation               Indicates the type of DMA (slave or bus master), and if
1045                                  the DMA operation is going to read or write to system memory.
1046   @param ChannelNumber           The slave channel number to use for this DMA operation.
1047                                  If Operation and ChannelAttributes shows that this device
1048                                  performs bus mastering DMA, then this field is ignored.
1049                                  The legal range for this field is 0..7.
1050   @param ChannelAttributes       The attributes of the DMA channel to use for this DMA operation
1051   @param HostAddress             The system memory address to map to the device.
1052   @param NumberOfBytes           On input the number of bytes to map.  On output the number
1053                                  of bytes that were mapped.
1054   @param DeviceAddress           The resulting map address for the bus master device to use
1055                                  to access the hosts HostAddress.
1056   @param Mapping                 A resulting value to pass to EFI_ISA_IO.Unmap().
1057
1058   @retval EFI_SUCCESS            The range was mapped for the returned NumberOfBytes.
1059   @retval EFI_INVALID_PARAMETER  The Operation or HostAddress is undefined.
1060   @retval EFI_UNSUPPORTED        The HostAddress can not be mapped as a common buffer.
1061   @retval EFI_DEVICE_ERROR       The system hardware could not map the requested address.
1062   @retval EFI_OUT_OF_RESOURCES   The memory pages could not be allocated.
1063 **/
1064 EFI_STATUS
1065 IsaIoMapOnlySupportSlaveReadWrite (
1066   IN     EFI_ISA_IO_PROTOCOL            *This,
1067   IN     EFI_ISA_IO_PROTOCOL_OPERATION  Operation,
1068   IN     UINT8                          ChannelNumber  OPTIONAL,
1069   IN     UINT32                         ChannelAttributes,
1070   IN     VOID                           *HostAddress,
1071   IN OUT UINTN                          *NumberOfBytes,
1072   OUT    EFI_PHYSICAL_ADDRESS           *DeviceAddress,
1073   OUT    VOID                           **Mapping
1074   )
1075 {
1076   EFI_STATUS            Status;
1077   EFI_PHYSICAL_ADDRESS  PhysicalAddress;
1078   ISA_MAP_INFO          *IsaMapInfo;
1079   UINT8                 DmaMode;
1080   UINTN                 MaxNumberOfBytes;
1081   UINT32                BaseAddress;
1082   UINT16                Count;
1083   UINT8                 DmaMask;
1084   UINT8                 DmaClear;
1085   UINT8                 DmaChannelMode;
1086
1087   if ((NULL == This) ||
1088       (NULL == HostAddress) ||
1089       (NULL == NumberOfBytes) ||
1090       (NULL == DeviceAddress) ||
1091       (NULL == Mapping)
1092       ) {
1093     return EFI_INVALID_PARAMETER;
1094   }
1095
1096   //
1097   // Initialize the return values to their defaults
1098   //
1099   *Mapping = NULL;
1100
1101   //
1102   // Make sure the Operation parameter is valid.
1103   // Light IsaIo only supports two operations.
1104   //
1105   if (!(Operation == EfiIsaIoOperationSlaveRead ||
1106         Operation == EfiIsaIoOperationSlaveWrite)) {
1107     return EFI_INVALID_PARAMETER;
1108   }
1109
1110   if (ChannelNumber >= 4) {
1111     //
1112     // The Light IsaIo doesn't support channelNumber larger than 4.
1113     //
1114     return EFI_INVALID_PARAMETER;
1115   }
1116
1117   //
1118   // Map the HostAddress to a DeviceAddress.
1119   //
1120   PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress;
1121   if ((PhysicalAddress + *NumberOfBytes) > BASE_16MB) {
1122     //
1123     // Common Buffer operations can not be remapped.  If the common buffer
1124     // is above 16MB, then it is not possible to generate a mapping, so return
1125     // an error.
1126     //
1127     if (Operation == EfiIsaIoOperationBusMasterCommonBuffer) {
1128       return EFI_UNSUPPORTED;
1129     }
1130     //
1131     // Allocate an ISA_MAP_INFO structure to remember the mapping when Unmap()
1132     // is called later.
1133     //
1134     IsaMapInfo = AllocatePool (sizeof (ISA_MAP_INFO));
1135     if (IsaMapInfo == NULL) {
1136       *NumberOfBytes = 0;
1137       return EFI_OUT_OF_RESOURCES;
1138     }
1139     //
1140     // Return a pointer to the MAP_INFO structure in Mapping
1141     //
1142     *Mapping = IsaMapInfo;
1143
1144     //
1145     // Initialize the MAP_INFO structure
1146     //
1147     IsaMapInfo->Operation         = Operation;
1148     IsaMapInfo->NumberOfBytes     = *NumberOfBytes;
1149     IsaMapInfo->NumberOfPages     = EFI_SIZE_TO_PAGES (*NumberOfBytes);
1150     IsaMapInfo->HostAddress       = PhysicalAddress;
1151     IsaMapInfo->MappedHostAddress = BASE_16MB - 1;
1152
1153     //
1154     // Allocate a buffer below 16MB to map the transfer to.
1155     //
1156     Status = gBS->AllocatePages (
1157                     AllocateMaxAddress,
1158                     EfiBootServicesData,
1159                     IsaMapInfo->NumberOfPages,
1160                     &IsaMapInfo->MappedHostAddress
1161                     );
1162     if (EFI_ERROR (Status)) {
1163       FreePool (IsaMapInfo);
1164       *NumberOfBytes  = 0;
1165       *Mapping        = NULL;
1166       return Status;
1167     }
1168     //
1169     // If this is a read operation from the DMA agents's point of view,
1170     // then copy the contents of the real buffer into the mapped buffer
1171     // so the DMA agent can read the contents of the real buffer.
1172     //
1173     if (Operation == EfiIsaIoOperationSlaveRead) {
1174       CopyMem (
1175         (VOID *) (UINTN) IsaMapInfo->MappedHostAddress,
1176         (VOID *) (UINTN) IsaMapInfo->HostAddress,
1177         IsaMapInfo->NumberOfBytes
1178         );
1179     }
1180     //
1181     // The DeviceAddress is the address of the maped buffer below 16 MB
1182     //
1183     *DeviceAddress = IsaMapInfo->MappedHostAddress;
1184   } else {
1185     //
1186     // The transfer is below 16 MB, so the DeviceAddress is simply the
1187     // HostAddress
1188     //
1189     *DeviceAddress = PhysicalAddress;
1190   }
1191
1192   //
1193   // Figure out what to program into the DMA Channel Mode Register
1194   //
1195   DmaMode = (UINT8) (B_8237_DMA_CHMODE_INCREMENT | (ChannelNumber & 0x03));
1196   if (Operation == EfiIsaIoOperationSlaveRead) {
1197     DmaMode |= V_8237_DMA_CHMODE_MEM2IO;
1198   } else {
1199     DmaMode |= V_8237_DMA_CHMODE_IO2MEM;
1200   }
1201   //
1202   // We only support EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE in simplified IsaIo
1203   //
1204   DmaMode |= V_8237_DMA_CHMODE_SINGLE;
1205
1206   //
1207   // A Slave DMA transfer can not cross a 64K boundary.
1208   // Compute *NumberOfBytes based on this restriction.
1209   //
1210   MaxNumberOfBytes = 0x10000 - ((UINT32) (*DeviceAddress) & 0xffff);
1211   if (*NumberOfBytes > MaxNumberOfBytes) {
1212     *NumberOfBytes = MaxNumberOfBytes;
1213   }
1214   //
1215   // Compute the values to program into the BaseAddress and Count registers
1216   // of the Slave DMA controller
1217   //
1218   BaseAddress = (UINT32) (*DeviceAddress);
1219   Count       = (UINT16) (*NumberOfBytes - 1);
1220   //
1221   // Program the DMA Write Single Mask Register for ChannelNumber
1222   // Clear the DMA Byte Pointer Register
1223   //
1224   DmaMask         = R_8237_DMA_WRSMSK_CH0_3;
1225   DmaClear        = R_8237_DMA_CBPR_CH0_3;
1226   DmaChannelMode  = R_8237_DMA_CHMODE_CH0_3;
1227
1228   Status = WritePort (
1229              This,
1230              DmaMask,
1231              (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03))
1232              );
1233   if (EFI_ERROR (Status)) {
1234     return Status;
1235   }
1236
1237   Status = WritePort (
1238              This,
1239              DmaClear,
1240              (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03))
1241              );
1242   if (EFI_ERROR (Status)) {
1243     return Status;
1244   }
1245
1246   Status = WritePort (This, DmaChannelMode, DmaMode);
1247   if (EFI_ERROR (Status)) {
1248     return Status;
1249   }
1250
1251   Status = WriteDmaPort (
1252              This,
1253              mDmaRegisters[ChannelNumber].Address,
1254              mDmaRegisters[ChannelNumber].Page,
1255              mDmaRegisters[ChannelNumber].Count,
1256              BaseAddress,
1257              Count
1258              );
1259   if (EFI_ERROR (Status)) {
1260     return Status;
1261   }
1262
1263   Status = WritePort (
1264              This,
1265              DmaMask,
1266              (UINT8) (ChannelNumber & 0x03)
1267              );
1268   if (EFI_ERROR (Status)) {
1269     return Status;
1270   }
1271
1272   return EFI_SUCCESS;
1273 }
1274
1275 /**
1276   Maps a memory region for DMA. This implementation implement the
1277   the full mapping support.
1278
1279   @param This                    A pointer to the EFI_ISA_IO_PROTOCOL instance.
1280   @param Operation               Indicates the type of DMA (slave or bus master), and if
1281                                  the DMA operation is going to read or write to system memory.
1282   @param ChannelNumber           The slave channel number to use for this DMA operation.
1283                                  If Operation and ChannelAttributes shows that this device
1284                                  performs bus mastering DMA, then this field is ignored.
1285                                  The legal range for this field is 0..7.
1286   @param ChannelAttributes       The attributes of the DMA channel to use for this DMA operation
1287   @param HostAddress             The system memory address to map to the device.
1288   @param NumberOfBytes           On input the number of bytes to map.  On output the number
1289                                  of bytes that were mapped.
1290   @param DeviceAddress           The resulting map address for the bus master device to use
1291                                  to access the hosts HostAddress.
1292   @param Mapping                 A resulting value to pass to EFI_ISA_IO.Unmap().
1293
1294   @retval EFI_SUCCESS           - The range was mapped for the returned NumberOfBytes.
1295   @retval EFI_INVALID_PARAMETER - The Operation or HostAddress is undefined.
1296   @retval EFI_UNSUPPORTED       - The HostAddress can not be mapped as a common buffer.
1297   @retval EFI_DEVICE_ERROR      - The system hardware could not map the requested address.
1298   @retval EFI_OUT_OF_RESOURCES  - The memory pages could not be allocated.
1299 **/
1300 EFI_STATUS
1301 IsaIoMapFullSupport (
1302   IN     EFI_ISA_IO_PROTOCOL                                  *This,
1303   IN     EFI_ISA_IO_PROTOCOL_OPERATION                        Operation,
1304   IN     UINT8                                                ChannelNumber         OPTIONAL,
1305   IN     UINT32                                               ChannelAttributes,
1306   IN     VOID                                                 *HostAddress,
1307   IN OUT UINTN                                                *NumberOfBytes,
1308   OUT    EFI_PHYSICAL_ADDRESS                                 *DeviceAddress,
1309   OUT    VOID                                                 **Mapping
1310   )
1311 {
1312   EFI_STATUS            Status;
1313   BOOLEAN               Master;
1314   BOOLEAN               Read;
1315   EFI_PHYSICAL_ADDRESS  PhysicalAddress;
1316   ISA_MAP_INFO          *IsaMapInfo;
1317   UINT8                 DmaMode;
1318   UINTN                 MaxNumberOfBytes;
1319   UINT32                BaseAddress;
1320   UINT16                Count;
1321   UINT8                 DmaMask;
1322   UINT8                 DmaClear;
1323   UINT8                 DmaChannelMode;
1324
1325   if ((NULL == This) ||
1326       (NULL == HostAddress) ||
1327       (NULL == NumberOfBytes) ||
1328       (NULL == DeviceAddress) ||
1329       (NULL == Mapping)
1330       ) {
1331     return EFI_INVALID_PARAMETER;
1332   }
1333
1334   //
1335   // Initialize the return values to their defaults
1336   //
1337   *Mapping = NULL;
1338
1339   //
1340   // Make sure the Operation parameter is valid
1341   //
1342   if ((UINT32)Operation >= EfiIsaIoOperationMaximum) {
1343     return EFI_INVALID_PARAMETER;
1344   }
1345
1346   if (ChannelNumber >= 8) {
1347     return EFI_INVALID_PARAMETER;
1348   }
1349
1350   //
1351   // See if this is a Slave DMA Operation
1352   //
1353   Master  = TRUE;
1354   Read    = FALSE;
1355   if (Operation == EfiIsaIoOperationSlaveRead) {
1356     Operation = EfiIsaIoOperationBusMasterRead;
1357     Master    = FALSE;
1358     Read      = TRUE;
1359   }
1360
1361   if (Operation == EfiIsaIoOperationSlaveWrite) {
1362     Operation = EfiIsaIoOperationBusMasterWrite;
1363     Master    = FALSE;
1364     Read      = FALSE;
1365   }
1366
1367   if (!Master) {
1368     //
1369     // Make sure that ChannelNumber is a valid channel number
1370     // Channel 4 is used to cascade, so it is illegal.
1371     //
1372     if (ChannelNumber == 4 || ChannelNumber > 7) {
1373       return EFI_INVALID_PARAMETER;
1374     }
1375     //
1376     // This implementation only support COMPATIBLE DMA Transfers
1377     //
1378     if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_COMPATIBLE) == 0) {
1379       return EFI_INVALID_PARAMETER;
1380     }
1381
1382     if ((ChannelAttributes &
1383          (EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_A |
1384           EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_B |
1385           EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_C)) != 0) {
1386       return EFI_INVALID_PARAMETER;
1387     }
1388
1389     if (ChannelNumber < 4) {
1390       //
1391       // If this is Channel 0..3, then the width must be 8 bit
1392       //
1393       if (((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8) == 0) ||
1394           ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16) != 0)
1395           ) {
1396         return EFI_INVALID_PARAMETER;
1397       }
1398     } else {
1399       //
1400       // If this is Channel 4..7, then the width must be 16 bit
1401       //
1402       if (((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8) != 0) ||
1403           ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16) == 0)) {
1404         return EFI_INVALID_PARAMETER;
1405       }
1406     }
1407     //
1408     // Either Demand Mode or Single Mode must be selected, but not both
1409     //
1410     if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE) != 0) {
1411       if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) != 0) {
1412         return EFI_INVALID_PARAMETER;
1413       }
1414     } else {
1415       if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) == 0) {
1416         return EFI_INVALID_PARAMETER;
1417       }
1418     }
1419   }
1420   //
1421   // Map the HostAddress to a DeviceAddress.
1422   //
1423   PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress;
1424   if ((PhysicalAddress +*NumberOfBytes) > BASE_16MB) {
1425     //
1426     // Common Buffer operations can not be remapped.  If the common buffer
1427     // is above 16MB, then it is not possible to generate a mapping, so return
1428     // an error.
1429     //
1430     if (Operation == EfiIsaIoOperationBusMasterCommonBuffer) {
1431       return EFI_UNSUPPORTED;
1432     }
1433     //
1434     // Allocate an ISA_MAP_INFO structure to remember the mapping when Unmap()
1435     // is called later.
1436     //
1437     IsaMapInfo = AllocatePool (sizeof (ISA_MAP_INFO));
1438     if (IsaMapInfo == NULL) {
1439       *NumberOfBytes = 0;
1440       return EFI_OUT_OF_RESOURCES;
1441     }
1442     //
1443     // Return a pointer to the MAP_INFO structure in Mapping
1444     //
1445     *Mapping = IsaMapInfo;
1446
1447     //
1448     // Initialize the MAP_INFO structure
1449     //
1450     IsaMapInfo->Operation         = Operation;
1451     IsaMapInfo->NumberOfBytes     = *NumberOfBytes;
1452     IsaMapInfo->NumberOfPages     = EFI_SIZE_TO_PAGES (*NumberOfBytes);
1453     IsaMapInfo->HostAddress       = PhysicalAddress;
1454     IsaMapInfo->MappedHostAddress = BASE_16MB - 1;
1455
1456     //
1457     // Allocate a buffer below 16MB to map the transfer to.
1458     //
1459     Status = gBS->AllocatePages (
1460                     AllocateMaxAddress,
1461                     EfiBootServicesData,
1462                     IsaMapInfo->NumberOfPages,
1463                     &IsaMapInfo->MappedHostAddress
1464                     );
1465     if (EFI_ERROR (Status)) {
1466       FreePool (IsaMapInfo);
1467       *NumberOfBytes  = 0;
1468       *Mapping        = NULL;
1469       return Status;
1470     }
1471     //
1472     // If this is a read operation from the DMA agents's point of view,
1473     // then copy the contents of the real buffer into the mapped buffer
1474     // so the DMA agent can read the contents of the real buffer.
1475     //
1476     if (Operation == EfiIsaIoOperationBusMasterRead) {
1477       CopyMem (
1478         (VOID *) (UINTN) IsaMapInfo->MappedHostAddress,
1479         (VOID *) (UINTN) IsaMapInfo->HostAddress,
1480         IsaMapInfo->NumberOfBytes
1481         );
1482     }
1483     //
1484     // The DeviceAddress is the address of the maped buffer below 16 MB
1485     //
1486     *DeviceAddress = IsaMapInfo->MappedHostAddress;
1487   } else {
1488     //
1489     // The transfer is below 16 MB, so the DeviceAddress is simply the
1490     // HostAddress
1491     //
1492     *DeviceAddress = PhysicalAddress;
1493   }
1494   //
1495   // If this is a Bus Master operation then return
1496   //
1497   if (Master) {
1498     return EFI_SUCCESS;
1499   }
1500   //
1501   // Figure out what to program into the DMA Channel Mode Register
1502   //
1503   DmaMode = (UINT8) (B_8237_DMA_CHMODE_INCREMENT | (ChannelNumber & 0x03));
1504   if (Read) {
1505     DmaMode |= V_8237_DMA_CHMODE_MEM2IO;
1506   } else {
1507     DmaMode |= V_8237_DMA_CHMODE_IO2MEM;
1508   }
1509
1510   if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_AUTO_INITIALIZE) != 0) {
1511     DmaMode |= B_8237_DMA_CHMODE_AE;
1512   }
1513
1514   if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) != 0) {
1515     DmaMode |= V_8237_DMA_CHMODE_DEMAND;
1516   }
1517
1518   if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE) != 0) {
1519     DmaMode |= V_8237_DMA_CHMODE_SINGLE;
1520   }
1521   //
1522   // A Slave DMA transfer can not cross a 64K boundary.
1523   // Compute *NumberOfBytes based on this restriction.
1524   //
1525   MaxNumberOfBytes = 0x10000 - ((UINT32) (*DeviceAddress) & 0xffff);
1526   if (*NumberOfBytes > MaxNumberOfBytes) {
1527     *NumberOfBytes = MaxNumberOfBytes;
1528   }
1529   //
1530   // Compute the values to program into the BaseAddress and Count registers
1531   // of the Slave DMA controller
1532   //
1533   if (ChannelNumber < 4) {
1534     BaseAddress = (UINT32) (*DeviceAddress);
1535     Count       = (UINT16) (*NumberOfBytes - 1);
1536   } else {
1537     BaseAddress = (UINT32) (((UINT32) (*DeviceAddress) & 0xff0000) | (((UINT32) (*DeviceAddress) & 0xffff) >> 1));
1538     Count       = (UINT16) ((*NumberOfBytes - 1) >> 1);
1539   }
1540   //
1541   // Program the DMA Write Single Mask Register for ChannelNumber
1542   // Clear the DMA Byte Pointer Register
1543   //
1544   if (ChannelNumber < 4) {
1545     DmaMask         = R_8237_DMA_WRSMSK_CH0_3;
1546     DmaClear        = R_8237_DMA_CBPR_CH0_3;
1547     DmaChannelMode  = R_8237_DMA_CHMODE_CH0_3;
1548   } else {
1549     DmaMask         = R_8237_DMA_WRSMSK_CH4_7;
1550     DmaClear        = R_8237_DMA_CBPR_CH4_7;
1551     DmaChannelMode  = R_8237_DMA_CHMODE_CH4_7;
1552   }
1553
1554   Status = WritePort (
1555              This,
1556              DmaMask,
1557              (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03))
1558              );
1559   if (EFI_ERROR (Status)) {
1560     return Status;
1561   }
1562
1563   Status = WritePort (
1564              This,
1565              DmaClear,
1566              (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03))
1567              );
1568   if (EFI_ERROR (Status)) {
1569     return Status;
1570   }
1571
1572   Status = WritePort (This, DmaChannelMode, DmaMode);
1573   if (EFI_ERROR (Status)) {
1574     return Status;
1575   }
1576
1577   Status = WriteDmaPort (
1578              This,
1579              mDmaRegisters[ChannelNumber].Address,
1580              mDmaRegisters[ChannelNumber].Page,
1581              mDmaRegisters[ChannelNumber].Count,
1582              BaseAddress,
1583              Count
1584              );
1585   if (EFI_ERROR (Status)) {
1586     return Status;
1587   }
1588
1589   Status = WritePort (
1590              This,
1591              DmaMask,
1592              (UINT8) (ChannelNumber & 0x03)
1593              );
1594   if (EFI_ERROR (Status)) {
1595     return Status;
1596   }
1597
1598   return EFI_SUCCESS;
1599 }
1600
1601 /**
1602   Maps a memory region for DMA
1603
1604   @param This                    A pointer to the EFI_ISA_IO_PROTOCOL instance.
1605   @param Operation               Indicates the type of DMA (slave or bus master), and if
1606                                  the DMA operation is going to read or write to system memory.
1607   @param ChannelNumber           The slave channel number to use for this DMA operation.
1608                                  If Operation and ChannelAttributes shows that this device
1609                                  performs bus mastering DMA, then this field is ignored.
1610                                  The legal range for this field is 0..7.
1611   @param ChannelAttributes       The attributes of the DMA channel to use for this DMA operation
1612   @param HostAddress             The system memory address to map to the device.
1613   @param NumberOfBytes           On input the number of bytes to map.  On output the number
1614                                  of bytes that were mapped.
1615   @param DeviceAddress           The resulting map address for the bus master device to use
1616                                  to access the hosts HostAddress.
1617   @param Mapping                 A resulting value to pass to EFI_ISA_IO.Unmap().
1618
1619   @retval EFI_SUCCESS            The range was mapped for the returned NumberOfBytes.
1620   @retval EFI_INVALID_PARAMETER  The Operation or HostAddress is undefined.
1621   @retval EFI_UNSUPPORTED        The HostAddress can not be mapped as a common buffer.
1622   @retval EFI_DEVICE_ERROR       The system hardware could not map the requested address.
1623   @retval EFI_OUT_OF_RESOURCES   The memory pages could not be allocated.
1624 **/
1625 EFI_STATUS
1626 EFIAPI
1627 IsaIoMap (
1628   IN     EFI_ISA_IO_PROTOCOL            *This,
1629   IN     EFI_ISA_IO_PROTOCOL_OPERATION  Operation,
1630   IN     UINT8                          ChannelNumber  OPTIONAL,
1631   IN     UINT32                         ChannelAttributes,
1632   IN     VOID                           *HostAddress,
1633   IN OUT UINTN                          *NumberOfBytes,
1634   OUT    EFI_PHYSICAL_ADDRESS           *DeviceAddress,
1635   OUT    VOID                           **Mapping
1636   )
1637 {
1638   //
1639   // Check if DMA is supported.
1640   //
1641   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) {
1642     return EFI_UNSUPPORTED;
1643   }
1644   //
1645   // Set Feature Flag PcdIsaBusSupportBusMaster to FALSE to disable support for
1646   // ISA Bus Master.
1647   //
1648   // So we just return EFI_UNSUPPORTED for these functions.
1649   //
1650   if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0) {
1651     return IsaIoMapOnlySupportSlaveReadWrite (
1652              This,
1653              Operation,
1654              ChannelNumber,
1655              ChannelAttributes,
1656              HostAddress,
1657              NumberOfBytes,
1658              DeviceAddress,
1659              Mapping
1660              );
1661
1662   } else {
1663     return IsaIoMapFullSupport (
1664              This,
1665              Operation,
1666              ChannelNumber,
1667              ChannelAttributes,
1668              HostAddress,
1669              NumberOfBytes,
1670              DeviceAddress,
1671              Mapping
1672              );
1673   }
1674 }
1675
1676 /**
1677   Allocates pages that are suitable for an EfiIsaIoOperationBusMasterCommonBuffer mapping.
1678
1679   @param[in]  This               A pointer to the EFI_ISA_IO_PROTOCOL instance.
1680   @param[in]  Type               The type allocation to perform.
1681   @param[in]  MemoryType         The type of memory to allocate.
1682   @param[in]  Pages              The number of pages to allocate.
1683   @param[out] HostAddress        A pointer to store the base address of the allocated range.
1684   @param[in]  Attributes         The requested bit mask of attributes for the allocated range.
1685
1686   @retval EFI_SUCCESS            The requested memory pages were allocated.
1687   @retval EFI_INVALID_PARAMETER  Type is invalid or MemoryType is invalid or HostAddress is NULL
1688   @retval EFI_UNSUPPORTED        Attributes is unsupported or the memory range specified
1689                                  by HostAddress, Pages, and Type is not available for common buffer use.
1690   @retval EFI_OUT_OF_RESOURCES   The memory pages could not be allocated.
1691 **/
1692 EFI_STATUS
1693 EFIAPI
1694 IsaIoAllocateBuffer (
1695   IN  EFI_ISA_IO_PROTOCOL  *This,
1696   IN  EFI_ALLOCATE_TYPE    Type,
1697   IN  EFI_MEMORY_TYPE      MemoryType,
1698   IN  UINTN                Pages,
1699   OUT VOID                 **HostAddress,
1700   IN  UINT64               Attributes
1701   )
1702 {
1703   EFI_STATUS            Status;
1704   EFI_PHYSICAL_ADDRESS  PhysicalAddress;
1705
1706   //
1707   // Set Feature Flag PcdIsaBusOnlySupportSlaveDma to FALSE to disable support for
1708   // ISA Bus Master.
1709   // Or unset Feature Flag PcdIsaBusSupportDma to disable support for ISA DMA.
1710   //
1711   if (((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) ||
1712       ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0)) {
1713     return EFI_UNSUPPORTED;
1714   }
1715
1716   if (HostAddress == NULL) {
1717     return EFI_INVALID_PARAMETER;
1718   }
1719
1720   if ((UINT32)Type >= MaxAllocateType) {
1721     return EFI_INVALID_PARAMETER;
1722   }
1723   //
1724   // The only valid memory types are EfiBootServicesData and EfiRuntimeServicesData
1725   //
1726   if (MemoryType != EfiBootServicesData && MemoryType != EfiRuntimeServicesData) {
1727     return EFI_INVALID_PARAMETER;
1728   }
1729
1730   if ((Attributes & ~(EFI_ISA_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE | EFI_ISA_IO_ATTRIBUTE_MEMORY_CACHED)) != 0) {
1731     return EFI_UNSUPPORTED;
1732   }
1733
1734   PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) (BASE_16MB - 1);
1735   if (Type == AllocateAddress) {
1736     if ((UINTN) (*HostAddress) >= BASE_16MB) {
1737       return EFI_UNSUPPORTED;
1738     } else {
1739       PhysicalAddress = (UINTN) (*HostAddress);
1740     }
1741   }
1742
1743   if (Type == AllocateAnyPages) {
1744     Type = AllocateMaxAddress;
1745   }
1746
1747   Status = gBS->AllocatePages (Type, MemoryType, Pages, &PhysicalAddress);
1748   if (EFI_ERROR (Status)) {
1749     REPORT_STATUS_CODE (
1750       EFI_ERROR_CODE | EFI_ERROR_MINOR,
1751       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
1752       );
1753     return Status;
1754   }
1755
1756   *HostAddress = (VOID *) (UINTN) PhysicalAddress;
1757   return Status;
1758 }
1759
1760 /**
1761   Frees memory that was allocated with EFI_ISA_IO.AllocateBuffer().
1762
1763   @param[in] This                A pointer to the EFI_ISA_IO_PROTOCOL instance.
1764   @param[in] Pages               The number of pages to free.
1765   @param[in] HostAddress         The base address of the allocated range.
1766
1767   @retval EFI_SUCCESS            The requested memory pages were freed.
1768   @retval EFI_INVALID_PARAMETER  The memory was not allocated with EFI_ISA_IO.AllocateBufer().
1769 **/
1770 EFI_STATUS
1771 EFIAPI
1772 IsaIoFreeBuffer (
1773   IN EFI_ISA_IO_PROTOCOL  *This,
1774   IN UINTN                Pages,
1775   IN VOID                 *HostAddress
1776   )
1777 {
1778   EFI_STATUS  Status;
1779
1780   //
1781   // Set Feature Flag PcdIsaBusOnlySupportSlaveDma to FALSE to disable support for
1782   // ISA Bus Master.
1783   // Or unset Feature Flag PcdIsaBusSupportDma to disable support for ISA DMA.
1784   //
1785   if (((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) ||
1786       ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0)) {
1787     return EFI_UNSUPPORTED;
1788   }
1789
1790   Status = gBS->FreePages (
1791                   (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress,
1792                   Pages
1793                   );
1794   if (EFI_ERROR (Status)) {
1795     REPORT_STATUS_CODE (
1796       EFI_ERROR_CODE | EFI_ERROR_MINOR,
1797       EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR
1798       );
1799   }
1800
1801   return Status;
1802 }
1803