1 /** @file 2 The implementation for EFI_ISA_IO_PROTOCOL. 3 4 Copyright (c) 2006 - 2012, 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 "InternalIsaIo.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 Initializes an ISA I/O Instance 85 86 @param[in] IsaIoDevice The iso device to be initialized. 87 @param[in] IsaDeviceResourceList The resource list. 88 89 **/ 90 VOID 91 InitializeIsaIoInstance ( 92 IN ISA_IO_DEVICE *IsaIoDevice, 93 IN EFI_ISA_ACPI_RESOURCE_LIST *IsaDeviceResourceList 94 ) 95 { 96 // 97 // Use the ISA IO Protocol structure template to initialize the ISA IO instance 98 // 99 CopyMem ( 100 &IsaIoDevice->IsaIo, 101 &mIsaIoInterface, 102 sizeof (EFI_ISA_IO_PROTOCOL) 103 ); 104 105 IsaIoDevice->IsaIo.ResourceList = IsaDeviceResourceList; 106 } 107 108 /** 109 Performs an ISA I/O Read Cycle 110 111 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 112 @param[in] Width Specifies the width of the I/O operation. 113 @param[in] Offset The offset in ISA I/O space to start the I/O operation. 114 @param[in] Count The number of I/O operations to perform. 115 @param[out] Buffer The destination buffer to store the results 116 117 @retval EFI_SUCCESS The data was read from the device sucessfully. 118 @retval EFI_UNSUPPORTED The Offset is not valid for this device. 119 @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. 120 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 121 **/ 122 EFI_STATUS 123 EFIAPI 124 IsaIoIoRead ( 125 IN EFI_ISA_IO_PROTOCOL *This, 126 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 127 IN UINT32 Offset, 128 IN UINTN Count, 129 OUT VOID *Buffer 130 ) 131 { 132 EFI_STATUS Status; 133 ISA_IO_DEVICE *IsaIoDevice; 134 135 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 136 137 // 138 // Verify Isa IO Access 139 // 140 Status = IsaIoVerifyAccess ( 141 IsaIoDevice, 142 IsaAccessTypeIo, 143 Width, 144 Count, 145 Offset 146 ); 147 if (EFI_ERROR (Status)) { 148 return Status; 149 } 150 151 Status = IsaIoDevice->PciIo->Io.Read ( 152 IsaIoDevice->PciIo, 153 (EFI_PCI_IO_PROTOCOL_WIDTH) Width, 154 EFI_PCI_IO_PASS_THROUGH_BAR, 155 Offset, 156 Count, 157 Buffer 158 ); 159 160 if (EFI_ERROR (Status)) { 161 REPORT_STATUS_CODE ( 162 EFI_ERROR_CODE | EFI_ERROR_MINOR, 163 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 164 ); 165 } 166 167 return Status; 168 } 169 170 /** 171 Performs an ISA I/O Write Cycle 172 173 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 174 @param[in] Width Specifies the width of the I/O operation. 175 @param[in] Offset The offset in ISA I/O space to start the I/O operation. 176 @param[in] Count The number of I/O operations to perform. 177 @param[in] Buffer The source buffer to write data from 178 179 @retval EFI_SUCCESS The data was writen to the device sucessfully. 180 @retval EFI_UNSUPPORTED The Offset is not valid for this device. 181 @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. 182 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 183 **/ 184 EFI_STATUS 185 EFIAPI 186 IsaIoIoWrite ( 187 IN EFI_ISA_IO_PROTOCOL *This, 188 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 189 IN UINT32 Offset, 190 IN UINTN Count, 191 IN VOID *Buffer 192 ) 193 { 194 EFI_STATUS Status; 195 ISA_IO_DEVICE *IsaIoDevice; 196 197 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 198 199 // 200 // Verify Isa IO Access 201 // 202 Status = IsaIoVerifyAccess ( 203 IsaIoDevice, 204 IsaAccessTypeIo, 205 Width, 206 Count, 207 Offset 208 ); 209 if (EFI_ERROR (Status)) { 210 return Status; 211 } 212 213 Status = IsaIoDevice->PciIo->Io.Write ( 214 IsaIoDevice->PciIo, 215 (EFI_PCI_IO_PROTOCOL_WIDTH) Width, 216 EFI_PCI_IO_PASS_THROUGH_BAR, 217 Offset, 218 Count, 219 Buffer 220 ); 221 222 if (EFI_ERROR (Status)) { 223 REPORT_STATUS_CODE ( 224 EFI_ERROR_CODE | EFI_ERROR_MINOR, 225 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 226 ); 227 } 228 229 return Status; 230 } 231 232 /** 233 Writes an 8-bit I/O Port 234 235 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 236 @param[in] Offset The offset in ISA IO space to start the IO operation. 237 @param[in] Value The data to write port. 238 239 @retval EFI_SUCCESS Success. 240 @retval EFI_INVALID_PARAMETER Parameter is invalid. 241 @retval EFI_UNSUPPORTED The address range specified by Offset is not valid. 242 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 243 **/ 244 EFI_STATUS 245 WritePort ( 246 IN EFI_ISA_IO_PROTOCOL *This, 247 IN UINT32 Offset, 248 IN UINT8 Value 249 ) 250 { 251 EFI_STATUS Status; 252 ISA_IO_DEVICE *IsaIoDevice; 253 254 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 255 256 Status = IsaIoDevice->PciIo->Io.Write ( 257 IsaIoDevice->PciIo, 258 EfiPciIoWidthUint8, 259 EFI_PCI_IO_PASS_THROUGH_BAR, 260 Offset, 261 1, 262 &Value 263 ); 264 if (EFI_ERROR (Status)) { 265 REPORT_STATUS_CODE ( 266 EFI_ERROR_CODE | EFI_ERROR_MINOR, 267 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 268 ); 269 return Status; 270 } 271 272 gBS->Stall (50); 273 274 return EFI_SUCCESS; 275 } 276 277 /** 278 Writes I/O operation base address and count number to a 8 bit I/O Port. 279 280 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 281 @param[in] AddrOffset The address' offset. 282 @param[in] PageOffset The page's offest. 283 @param[in] CountOffset The count's offset. 284 @param[in] BaseAddress The base address. 285 @param[in] Count The number of I/O operations to perform. 286 287 @retval EFI_SUCCESS Success. 288 @retval EFI_INVALID_PARAMETER Parameter is invalid. 289 @retval EFI_UNSUPPORTED The address range specified by these Offsets and Count is not valid. 290 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 291 **/ 292 EFI_STATUS 293 WriteDmaPort ( 294 IN EFI_ISA_IO_PROTOCOL *This, 295 IN UINT32 AddrOffset, 296 IN UINT32 PageOffset, 297 IN UINT32 CountOffset, 298 IN UINT32 BaseAddress, 299 IN UINT16 Count 300 ) 301 { 302 EFI_STATUS Status; 303 304 Status = WritePort (This, AddrOffset, (UINT8) (BaseAddress & 0xff)); 305 if (EFI_ERROR (Status)) { 306 return Status; 307 } 308 309 Status = WritePort (This, AddrOffset, (UINT8) ((BaseAddress >> 8) & 0xff)); 310 if (EFI_ERROR (Status)) { 311 return Status; 312 } 313 314 Status = WritePort (This, PageOffset, (UINT8) ((BaseAddress >> 16) & 0xff)); 315 if (EFI_ERROR (Status)) { 316 return Status; 317 } 318 319 Status = WritePort (This, CountOffset, (UINT8) (Count & 0xff)); 320 if (EFI_ERROR (Status)) { 321 return Status; 322 } 323 324 Status = WritePort (This, CountOffset, (UINT8) ((Count >> 8) & 0xff)); 325 return Status; 326 } 327 328 /** 329 Unmaps a memory region for DMA 330 331 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 332 @param[in] Mapping The mapping value returned from EFI_ISA_IO.Map(). 333 334 @retval EFI_SUCCESS The range was unmapped. 335 @retval EFI_DEVICE_ERROR The data was not committed to the target system memory. 336 **/ 337 EFI_STATUS 338 EFIAPI 339 IsaIoUnmap ( 340 IN EFI_ISA_IO_PROTOCOL *This, 341 IN VOID *Mapping 342 ) 343 { 344 ISA_MAP_INFO *IsaMapInfo; 345 346 // 347 // Check if DMA is supported. 348 // 349 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) { 350 return EFI_UNSUPPORTED; 351 } 352 353 // 354 // See if the Map() operation associated with this Unmap() required a mapping 355 // buffer.If a mapping buffer was not required, then this function simply 356 // returns EFI_SUCCESS. 357 // 358 if (Mapping != NULL) { 359 // 360 // Get the MAP_INFO structure from Mapping 361 // 362 IsaMapInfo = (ISA_MAP_INFO *) Mapping; 363 364 // 365 // If this is a write operation from the Agent's point of view, 366 // then copy the contents of the mapped buffer into the real buffer 367 // so the processor can read the contents of the real buffer. 368 // 369 if (IsaMapInfo->Operation == EfiIsaIoOperationBusMasterWrite) { 370 CopyMem ( 371 (VOID *) (UINTN) IsaMapInfo->HostAddress, 372 (VOID *) (UINTN) IsaMapInfo->MappedHostAddress, 373 IsaMapInfo->NumberOfBytes 374 ); 375 } 376 // 377 // Free the mapped buffer and the MAP_INFO structure. 378 // 379 gBS->FreePages (IsaMapInfo->MappedHostAddress, IsaMapInfo->NumberOfPages); 380 FreePool (IsaMapInfo); 381 } 382 383 return EFI_SUCCESS; 384 } 385 386 /** 387 Flushes any posted write data to the system memory. 388 389 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 390 391 @retval EFI_SUCCESS The buffers were flushed. 392 @retval EFI_DEVICE_ERROR The buffers were not flushed due to a hardware error. 393 **/ 394 EFI_STATUS 395 EFIAPI 396 IsaIoFlush ( 397 IN EFI_ISA_IO_PROTOCOL *This 398 ) 399 { 400 EFI_STATUS Status; 401 ISA_IO_DEVICE *IsaIoDevice; 402 403 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 404 405 Status = IsaIoDevice->PciIo->Flush (IsaIoDevice->PciIo); 406 407 if (EFI_ERROR (Status)) { 408 REPORT_STATUS_CODE ( 409 EFI_ERROR_CODE | EFI_ERROR_MINOR, 410 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 411 ); 412 } 413 414 return Status; 415 } 416 417 /** 418 Verifies access to an ISA device 419 420 @param[in] IsaIoDevice The ISA device to be verified. 421 @param[in] Type The Access type. The input must be either IsaAccessTypeMem or IsaAccessTypeIo. 422 @param[in] Width The width of the memory operation. 423 @param[in] Count The number of memory operations to perform. 424 @param[in] Offset The offset in ISA memory space to start the memory operation. 425 426 @retval EFI_SUCCESS Verify success. 427 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. 428 @retval EFI_UNSUPPORTED The device ont support the access type. 429 **/ 430 EFI_STATUS 431 IsaIoVerifyAccess ( 432 IN ISA_IO_DEVICE *IsaIoDevice, 433 IN ISA_ACCESS_TYPE Type, 434 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 435 IN UINTN Count, 436 IN UINT32 Offset 437 ) 438 { 439 EFI_ISA_ACPI_RESOURCE *Item; 440 EFI_STATUS Status; 441 442 if ((UINT32)Width >= EfiIsaIoWidthMaximum || 443 Width == EfiIsaIoWidthReserved || 444 Width == EfiIsaIoWidthFifoReserved || 445 Width == EfiIsaIoWidthFillReserved 446 ) { 447 return EFI_INVALID_PARAMETER; 448 } 449 450 // 451 // If Width is EfiIsaIoWidthFifoUintX then convert to EfiIsaIoWidthUintX 452 // If Width is EfiIsaIoWidthFillUintX then convert to EfiIsaIoWidthUintX 453 // 454 if (Width >= EfiIsaIoWidthFifoUint8 && Width < EfiIsaIoWidthFifoReserved) { 455 Count = 1; 456 } 457 458 Width = (EFI_ISA_IO_PROTOCOL_WIDTH) (Width & 0x03); 459 460 Status = EFI_UNSUPPORTED; 461 Item = IsaIoDevice->IsaIo.ResourceList->ResourceItem; 462 while (Item->Type != EfiIsaAcpiResourceEndOfList) { 463 if ((Type == IsaAccessTypeMem && Item->Type == EfiIsaAcpiResourceMemory) || 464 (Type == IsaAccessTypeIo && Item->Type == EfiIsaAcpiResourceIo)) { 465 if (Offset >= Item->StartRange && (Offset + Count * (UINT32)(1 << Width)) - 1 <= Item->EndRange) { 466 return EFI_SUCCESS; 467 } 468 469 if (Offset >= Item->StartRange && Offset <= Item->EndRange) { 470 Status = EFI_INVALID_PARAMETER; 471 } 472 } 473 474 Item++; 475 } 476 477 return Status; 478 } 479 480 /** 481 Performs an ISA Memory Read Cycle 482 483 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 484 @param[in] Width Specifies the width of the memory operation. 485 @param[in] Offset The offset in ISA memory space to start the memory operation. 486 @param[in] Count The number of memory operations to perform. 487 @param[out] Buffer The destination buffer to store the results 488 489 @retval EFI_SUCCESS The data was read from the device successfully. 490 @retval EFI_UNSUPPORTED The Offset is not valid for this device. 491 @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. 492 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 493 **/ 494 EFI_STATUS 495 EFIAPI 496 IsaIoMemRead ( 497 IN EFI_ISA_IO_PROTOCOL *This, 498 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 499 IN UINT32 Offset, 500 IN UINTN Count, 501 OUT VOID *Buffer 502 ) 503 { 504 EFI_STATUS Status; 505 ISA_IO_DEVICE *IsaIoDevice; 506 507 // 508 // Check if ISA memory is supported. 509 // 510 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) { 511 return EFI_UNSUPPORTED; 512 } 513 514 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 515 516 // 517 // Verify the Isa Io Access 518 // 519 Status = IsaIoVerifyAccess ( 520 IsaIoDevice, 521 IsaAccessTypeMem, 522 Width, 523 Count, 524 Offset 525 ); 526 if (EFI_ERROR (Status)) { 527 return Status; 528 } 529 530 Status = IsaIoDevice->PciIo->Mem.Read ( 531 IsaIoDevice->PciIo, 532 (EFI_PCI_IO_PROTOCOL_WIDTH) Width, 533 EFI_PCI_IO_PASS_THROUGH_BAR, 534 Offset, 535 Count, 536 Buffer 537 ); 538 539 if (EFI_ERROR (Status)) { 540 REPORT_STATUS_CODE ( 541 EFI_ERROR_CODE | EFI_ERROR_MINOR, 542 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 543 ); 544 } 545 546 return Status; 547 } 548 549 /** 550 Performs an ISA Memory Write Cycle 551 552 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 553 @param[in] Width Specifies the width of the memory operation. 554 @param[in] Offset The offset in ISA memory space to start the memory operation. 555 @param[in] Count The number of memory operations to perform. 556 @param[in] Buffer The source buffer to write data from 557 558 @retval EFI_SUCCESS The data was written to the device sucessfully. 559 @retval EFI_UNSUPPORTED The Offset is not valid for this device. 560 @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. 561 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 562 **/ 563 EFI_STATUS 564 EFIAPI 565 IsaIoMemWrite ( 566 IN EFI_ISA_IO_PROTOCOL *This, 567 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 568 IN UINT32 Offset, 569 IN UINTN Count, 570 IN VOID *Buffer 571 ) 572 { 573 EFI_STATUS Status; 574 ISA_IO_DEVICE *IsaIoDevice; 575 576 // 577 // Check if ISA memory is supported. 578 // 579 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) { 580 return EFI_UNSUPPORTED; 581 } 582 583 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 584 585 // 586 // Verify Isa IO Access 587 // 588 Status = IsaIoVerifyAccess ( 589 IsaIoDevice, 590 IsaAccessTypeMem, 591 Width, 592 Count, 593 Offset 594 ); 595 if (EFI_ERROR (Status)) { 596 return Status; 597 } 598 599 Status = IsaIoDevice->PciIo->Mem.Write ( 600 IsaIoDevice->PciIo, 601 (EFI_PCI_IO_PROTOCOL_WIDTH) Width, 602 EFI_PCI_IO_PASS_THROUGH_BAR, 603 Offset, 604 Count, 605 Buffer 606 ); 607 608 if (EFI_ERROR (Status)) { 609 REPORT_STATUS_CODE ( 610 EFI_ERROR_CODE | EFI_ERROR_MINOR, 611 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 612 ); 613 } 614 615 return Status; 616 } 617 618 /** 619 Copy one region of ISA memory space to another region of ISA memory space on the ISA controller. 620 621 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 622 @param[in] Width Specifies the width of the memory copy operation. 623 @param[in] DestOffset The offset of the destination 624 @param[in] SrcOffset The offset of the source 625 @param[in] Count The number of memory copy operations to perform 626 627 @retval EFI_SUCCESS The data was copied sucessfully. 628 @retval EFI_UNSUPPORTED The DestOffset or SrcOffset is not valid for this device. 629 @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid. 630 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 631 **/ 632 EFI_STATUS 633 EFIAPI 634 IsaIoCopyMem ( 635 IN EFI_ISA_IO_PROTOCOL *This, 636 IN EFI_ISA_IO_PROTOCOL_WIDTH Width, 637 IN UINT32 DestOffset, 638 IN UINT32 SrcOffset, 639 IN UINTN Count 640 ) 641 { 642 EFI_STATUS Status; 643 ISA_IO_DEVICE *IsaIoDevice; 644 645 // 646 // Check if ISA memory is supported. 647 // 648 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_ISA_MEMORY) == 0) { 649 return EFI_UNSUPPORTED; 650 } 651 652 IsaIoDevice = ISA_IO_DEVICE_FROM_ISA_IO_THIS (This); 653 654 // 655 // Verify Isa IO Access for destination and source 656 // 657 Status = IsaIoVerifyAccess ( 658 IsaIoDevice, 659 IsaAccessTypeMem, 660 Width, 661 Count, 662 DestOffset 663 ); 664 if (EFI_ERROR (Status)) { 665 return Status; 666 } 667 668 Status = IsaIoVerifyAccess ( 669 IsaIoDevice, 670 IsaAccessTypeMem, 671 Width, 672 Count, 673 SrcOffset 674 ); 675 if (EFI_ERROR (Status)) { 676 return Status; 677 } 678 679 Status = IsaIoDevice->PciIo->CopyMem ( 680 IsaIoDevice->PciIo, 681 (EFI_PCI_IO_PROTOCOL_WIDTH) Width, 682 EFI_PCI_IO_PASS_THROUGH_BAR, 683 DestOffset, 684 EFI_PCI_IO_PASS_THROUGH_BAR, 685 SrcOffset, 686 Count 687 ); 688 689 if (EFI_ERROR (Status)) { 690 REPORT_STATUS_CODE ( 691 EFI_ERROR_CODE | EFI_ERROR_MINOR, 692 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 693 ); 694 } 695 696 return Status; 697 } 698 699 /** 700 Maps a memory region for DMA, note this implementation 701 only supports slave read/write operation to save code size. 702 703 @param This A pointer to the EFI_ISA_IO_PROTOCOL instance. 704 @param Operation Indicates the type of DMA (slave or bus master), and if 705 the DMA operation is going to read or write to system memory. 706 @param ChannelNumber The slave channel number to use for this DMA operation. 707 If Operation and ChannelAttributes shows that this device 708 performs bus mastering DMA, then this field is ignored. 709 The legal range for this field is 0..7. 710 @param ChannelAttributes The attributes of the DMA channel to use for this DMA operation 711 @param HostAddress The system memory address to map to the device. 712 @param NumberOfBytes On input the number of bytes to map. On output the number 713 of bytes that were mapped. 714 @param DeviceAddress The resulting map address for the bus master device to use 715 to access the hosts HostAddress. 716 @param Mapping A resulting value to pass to EFI_ISA_IO.Unmap(). 717 718 @retval EFI_SUCCESS The range was mapped for the returned NumberOfBytes. 719 @retval EFI_INVALID_PARAMETER The Operation or HostAddress is undefined. 720 @retval EFI_UNSUPPORTED The HostAddress can not be mapped as a common buffer. 721 @retval EFI_DEVICE_ERROR The system hardware could not map the requested address. 722 @retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated. 723 **/ 724 EFI_STATUS 725 IsaIoMapOnlySupportSlaveReadWrite ( 726 IN EFI_ISA_IO_PROTOCOL *This, 727 IN EFI_ISA_IO_PROTOCOL_OPERATION Operation, 728 IN UINT8 ChannelNumber OPTIONAL, 729 IN UINT32 ChannelAttributes, 730 IN VOID *HostAddress, 731 IN OUT UINTN *NumberOfBytes, 732 OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, 733 OUT VOID **Mapping 734 ) 735 { 736 EFI_STATUS Status; 737 EFI_PHYSICAL_ADDRESS PhysicalAddress; 738 ISA_MAP_INFO *IsaMapInfo; 739 UINT8 DmaMode; 740 UINTN MaxNumberOfBytes; 741 UINT32 BaseAddress; 742 UINT16 Count; 743 UINT8 DmaMask; 744 UINT8 DmaClear; 745 UINT8 DmaChannelMode; 746 747 if ((NULL == This) || 748 (NULL == HostAddress) || 749 (NULL == NumberOfBytes) || 750 (NULL == DeviceAddress) || 751 (NULL == Mapping) 752 ) { 753 return EFI_INVALID_PARAMETER; 754 } 755 756 // 757 // Initialize the return values to their defaults 758 // 759 *Mapping = NULL; 760 761 // 762 // Make sure the Operation parameter is valid. 763 // Light IsaIo only supports two operations. 764 // 765 if (!(Operation == EfiIsaIoOperationSlaveRead || 766 Operation == EfiIsaIoOperationSlaveWrite)) { 767 return EFI_INVALID_PARAMETER; 768 } 769 770 if (ChannelNumber >= 4) { 771 // 772 // The Light IsaIo doesn't support channelNumber larger than 4. 773 // 774 return EFI_INVALID_PARAMETER; 775 } 776 777 // 778 // Map the HostAddress to a DeviceAddress. 779 // 780 PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress; 781 if ((PhysicalAddress + *NumberOfBytes) > ISA_MAX_MEMORY_ADDRESS) { 782 // 783 // Common Buffer operations can not be remapped. If the common buffer 784 // is above 16MB, then it is not possible to generate a mapping, so return 785 // an error. 786 // 787 if (Operation == EfiIsaIoOperationBusMasterCommonBuffer) { 788 return EFI_UNSUPPORTED; 789 } 790 // 791 // Allocate an ISA_MAP_INFO structure to remember the mapping when Unmap() 792 // is called later. 793 // 794 IsaMapInfo = AllocatePool (sizeof (ISA_MAP_INFO)); 795 if (IsaMapInfo == NULL) { 796 *NumberOfBytes = 0; 797 return EFI_OUT_OF_RESOURCES; 798 } 799 // 800 // Return a pointer to the MAP_INFO structure in Mapping 801 // 802 *Mapping = IsaMapInfo; 803 804 // 805 // Initialize the MAP_INFO structure 806 // 807 IsaMapInfo->Operation = Operation; 808 IsaMapInfo->NumberOfBytes = *NumberOfBytes; 809 IsaMapInfo->NumberOfPages = EFI_SIZE_TO_PAGES (*NumberOfBytes); 810 IsaMapInfo->HostAddress = PhysicalAddress; 811 IsaMapInfo->MappedHostAddress = ISA_MAX_MEMORY_ADDRESS - 1; 812 813 // 814 // Allocate a buffer below 16MB to map the transfer to. 815 // 816 Status = gBS->AllocatePages ( 817 AllocateMaxAddress, 818 EfiBootServicesData, 819 IsaMapInfo->NumberOfPages, 820 &IsaMapInfo->MappedHostAddress 821 ); 822 if (EFI_ERROR (Status)) { 823 FreePool (IsaMapInfo); 824 *NumberOfBytes = 0; 825 *Mapping = NULL; 826 return Status; 827 } 828 // 829 // If this is a read operation from the DMA agents's point of view, 830 // then copy the contents of the real buffer into the mapped buffer 831 // so the DMA agent can read the contents of the real buffer. 832 // 833 if (Operation == EfiIsaIoOperationSlaveRead) { 834 CopyMem ( 835 (VOID *) (UINTN) IsaMapInfo->MappedHostAddress, 836 (VOID *) (UINTN) IsaMapInfo->HostAddress, 837 IsaMapInfo->NumberOfBytes 838 ); 839 } 840 // 841 // The DeviceAddress is the address of the maped buffer below 16 MB 842 // 843 *DeviceAddress = IsaMapInfo->MappedHostAddress; 844 } else { 845 // 846 // The transfer is below 16 MB, so the DeviceAddress is simply the 847 // HostAddress 848 // 849 *DeviceAddress = PhysicalAddress; 850 } 851 852 // 853 // Figure out what to program into the DMA Channel Mode Register 854 // 855 DmaMode = (UINT8) (B_8237_DMA_CHMODE_INCREMENT | (ChannelNumber & 0x03)); 856 if (Operation == EfiIsaIoOperationSlaveRead) { 857 DmaMode |= V_8237_DMA_CHMODE_MEM2IO; 858 } else { 859 DmaMode |= V_8237_DMA_CHMODE_IO2MEM; 860 } 861 // 862 // We only support EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE in simplified IsaIo 863 // 864 DmaMode |= V_8237_DMA_CHMODE_SINGLE; 865 866 // 867 // A Slave DMA transfer can not cross a 64K boundary. 868 // Compute *NumberOfBytes based on this restriction. 869 // 870 MaxNumberOfBytes = 0x10000 - ((UINT32) (*DeviceAddress) & 0xffff); 871 if (*NumberOfBytes > MaxNumberOfBytes) { 872 *NumberOfBytes = MaxNumberOfBytes; 873 } 874 // 875 // Compute the values to program into the BaseAddress and Count registers 876 // of the Slave DMA controller 877 // 878 BaseAddress = (UINT32) (*DeviceAddress); 879 Count = (UINT16) (*NumberOfBytes - 1); 880 // 881 // Program the DMA Write Single Mask Register for ChannelNumber 882 // Clear the DMA Byte Pointer Register 883 // 884 DmaMask = R_8237_DMA_WRSMSK_CH0_3; 885 DmaClear = R_8237_DMA_CBPR_CH0_3; 886 DmaChannelMode = R_8237_DMA_CHMODE_CH0_3; 887 888 Status = WritePort ( 889 This, 890 DmaMask, 891 (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03)) 892 ); 893 if (EFI_ERROR (Status)) { 894 return Status; 895 } 896 897 Status = WritePort ( 898 This, 899 DmaClear, 900 (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03)) 901 ); 902 if (EFI_ERROR (Status)) { 903 return Status; 904 } 905 906 Status = WritePort (This, DmaChannelMode, DmaMode); 907 if (EFI_ERROR (Status)) { 908 return Status; 909 } 910 911 Status = WriteDmaPort ( 912 This, 913 mDmaRegisters[ChannelNumber].Address, 914 mDmaRegisters[ChannelNumber].Page, 915 mDmaRegisters[ChannelNumber].Count, 916 BaseAddress, 917 Count 918 ); 919 if (EFI_ERROR (Status)) { 920 return Status; 921 } 922 923 Status = WritePort ( 924 This, 925 DmaMask, 926 (UINT8) (ChannelNumber & 0x03) 927 ); 928 if (EFI_ERROR (Status)) { 929 return Status; 930 } 931 932 return EFI_SUCCESS; 933 } 934 935 /** 936 Maps a memory region for DMA. This implementation implement the 937 the full mapping support. 938 939 @param This A pointer to the EFI_ISA_IO_PROTOCOL instance. 940 @param Operation Indicates the type of DMA (slave or bus master), and if 941 the DMA operation is going to read or write to system memory. 942 @param ChannelNumber The slave channel number to use for this DMA operation. 943 If Operation and ChannelAttributes shows that this device 944 performs bus mastering DMA, then this field is ignored. 945 The legal range for this field is 0..7. 946 @param ChannelAttributes The attributes of the DMA channel to use for this DMA operation 947 @param HostAddress The system memory address to map to the device. 948 @param NumberOfBytes On input the number of bytes to map. On output the number 949 of bytes that were mapped. 950 @param DeviceAddress The resulting map address for the bus master device to use 951 to access the hosts HostAddress. 952 @param Mapping A resulting value to pass to EFI_ISA_IO.Unmap(). 953 954 @retval EFI_SUCCESS - The range was mapped for the returned NumberOfBytes. 955 @retval EFI_INVALID_PARAMETER - The Operation or HostAddress is undefined. 956 @retval EFI_UNSUPPORTED - The HostAddress can not be mapped as a common buffer. 957 @retval EFI_DEVICE_ERROR - The system hardware could not map the requested address. 958 @retval EFI_OUT_OF_RESOURCES - The memory pages could not be allocated. 959 **/ 960 EFI_STATUS 961 IsaIoMapFullSupport ( 962 IN EFI_ISA_IO_PROTOCOL *This, 963 IN EFI_ISA_IO_PROTOCOL_OPERATION Operation, 964 IN UINT8 ChannelNumber OPTIONAL, 965 IN UINT32 ChannelAttributes, 966 IN VOID *HostAddress, 967 IN OUT UINTN *NumberOfBytes, 968 OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, 969 OUT VOID **Mapping 970 ) 971 { 972 EFI_STATUS Status; 973 BOOLEAN Master; 974 BOOLEAN Read; 975 EFI_PHYSICAL_ADDRESS PhysicalAddress; 976 ISA_MAP_INFO *IsaMapInfo; 977 UINT8 DmaMode; 978 UINTN MaxNumberOfBytes; 979 UINT32 BaseAddress; 980 UINT16 Count; 981 UINT8 DmaMask; 982 UINT8 DmaClear; 983 UINT8 DmaChannelMode; 984 985 if ((NULL == This) || 986 (NULL == HostAddress) || 987 (NULL == NumberOfBytes) || 988 (NULL == DeviceAddress) || 989 (NULL == Mapping) 990 ) { 991 return EFI_INVALID_PARAMETER; 992 } 993 994 // 995 // Initialize the return values to their defaults 996 // 997 *Mapping = NULL; 998 999 // 1000 // Make sure the Operation parameter is valid 1001 // 1002 if ((UINT32)Operation >= EfiIsaIoOperationMaximum) { 1003 return EFI_INVALID_PARAMETER; 1004 } 1005 1006 if (ChannelNumber >= 8) { 1007 return EFI_INVALID_PARAMETER; 1008 } 1009 1010 // 1011 // See if this is a Slave DMA Operation 1012 // 1013 Master = TRUE; 1014 Read = FALSE; 1015 if (Operation == EfiIsaIoOperationSlaveRead) { 1016 Operation = EfiIsaIoOperationBusMasterRead; 1017 Master = FALSE; 1018 Read = TRUE; 1019 } 1020 1021 if (Operation == EfiIsaIoOperationSlaveWrite) { 1022 Operation = EfiIsaIoOperationBusMasterWrite; 1023 Master = FALSE; 1024 Read = FALSE; 1025 } 1026 1027 if (!Master) { 1028 // 1029 // Make sure that ChannelNumber is a valid channel number 1030 // Channel 4 is used to cascade, so it is illegal. 1031 // 1032 if (ChannelNumber == 4 || ChannelNumber > 7) { 1033 return EFI_INVALID_PARAMETER; 1034 } 1035 // 1036 // This implementation only support COMPATIBLE DMA Transfers 1037 // 1038 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_COMPATIBLE) == 0) { 1039 return EFI_INVALID_PARAMETER; 1040 } 1041 1042 if ((ChannelAttributes & 1043 (EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_A | 1044 EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_B | 1045 EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SPEED_C)) != 0) { 1046 return EFI_INVALID_PARAMETER; 1047 } 1048 1049 if (ChannelNumber < 4) { 1050 // 1051 // If this is Channel 0..3, then the width must be 8 bit 1052 // 1053 if (((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8) == 0) || 1054 ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16) != 0) 1055 ) { 1056 return EFI_INVALID_PARAMETER; 1057 } 1058 } else { 1059 // 1060 // If this is Channel 4..7, then the width must be 16 bit 1061 // 1062 if (((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_8) != 0) || 1063 ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_WIDTH_16) == 0)) { 1064 return EFI_INVALID_PARAMETER; 1065 } 1066 } 1067 // 1068 // Either Demand Mode or Single Mode must be selected, but not both 1069 // 1070 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE) != 0) { 1071 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) != 0) { 1072 return EFI_INVALID_PARAMETER; 1073 } 1074 } else { 1075 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) == 0) { 1076 return EFI_INVALID_PARAMETER; 1077 } 1078 } 1079 } 1080 // 1081 // Map the HostAddress to a DeviceAddress. 1082 // 1083 PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress; 1084 if ((PhysicalAddress +*NumberOfBytes) > ISA_MAX_MEMORY_ADDRESS) { 1085 // 1086 // Common Buffer operations can not be remapped. If the common buffer 1087 // is above 16MB, then it is not possible to generate a mapping, so return 1088 // an error. 1089 // 1090 if (Operation == EfiIsaIoOperationBusMasterCommonBuffer) { 1091 return EFI_UNSUPPORTED; 1092 } 1093 // 1094 // Allocate an ISA_MAP_INFO structure to remember the mapping when Unmap() 1095 // is called later. 1096 // 1097 IsaMapInfo = AllocatePool (sizeof (ISA_MAP_INFO)); 1098 if (IsaMapInfo == NULL) { 1099 *NumberOfBytes = 0; 1100 return EFI_OUT_OF_RESOURCES; 1101 } 1102 // 1103 // Return a pointer to the MAP_INFO structure in Mapping 1104 // 1105 *Mapping = IsaMapInfo; 1106 1107 // 1108 // Initialize the MAP_INFO structure 1109 // 1110 IsaMapInfo->Operation = Operation; 1111 IsaMapInfo->NumberOfBytes = *NumberOfBytes; 1112 IsaMapInfo->NumberOfPages = EFI_SIZE_TO_PAGES (*NumberOfBytes); 1113 IsaMapInfo->HostAddress = PhysicalAddress; 1114 IsaMapInfo->MappedHostAddress = ISA_MAX_MEMORY_ADDRESS - 1; 1115 1116 // 1117 // Allocate a buffer below 16MB to map the transfer to. 1118 // 1119 Status = gBS->AllocatePages ( 1120 AllocateMaxAddress, 1121 EfiBootServicesData, 1122 IsaMapInfo->NumberOfPages, 1123 &IsaMapInfo->MappedHostAddress 1124 ); 1125 if (EFI_ERROR (Status)) { 1126 FreePool (IsaMapInfo); 1127 *NumberOfBytes = 0; 1128 *Mapping = NULL; 1129 return Status; 1130 } 1131 // 1132 // If this is a read operation from the DMA agents's point of view, 1133 // then copy the contents of the real buffer into the mapped buffer 1134 // so the DMA agent can read the contents of the real buffer. 1135 // 1136 if (Operation == EfiIsaIoOperationBusMasterRead) { 1137 CopyMem ( 1138 (VOID *) (UINTN) IsaMapInfo->MappedHostAddress, 1139 (VOID *) (UINTN) IsaMapInfo->HostAddress, 1140 IsaMapInfo->NumberOfBytes 1141 ); 1142 } 1143 // 1144 // The DeviceAddress is the address of the maped buffer below 16 MB 1145 // 1146 *DeviceAddress = IsaMapInfo->MappedHostAddress; 1147 } else { 1148 // 1149 // The transfer is below 16 MB, so the DeviceAddress is simply the 1150 // HostAddress 1151 // 1152 *DeviceAddress = PhysicalAddress; 1153 } 1154 // 1155 // If this is a Bus Master operation then return 1156 // 1157 if (Master) { 1158 return EFI_SUCCESS; 1159 } 1160 // 1161 // Figure out what to program into the DMA Channel Mode Register 1162 // 1163 DmaMode = (UINT8) (B_8237_DMA_CHMODE_INCREMENT | (ChannelNumber & 0x03)); 1164 if (Read) { 1165 DmaMode |= V_8237_DMA_CHMODE_MEM2IO; 1166 } else { 1167 DmaMode |= V_8237_DMA_CHMODE_IO2MEM; 1168 } 1169 1170 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_AUTO_INITIALIZE) != 0) { 1171 DmaMode |= B_8237_DMA_CHMODE_AE; 1172 } 1173 1174 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_DEMAND_MODE) != 0) { 1175 DmaMode |= V_8237_DMA_CHMODE_DEMAND; 1176 } 1177 1178 if ((ChannelAttributes & EFI_ISA_IO_SLAVE_DMA_ATTRIBUTE_SINGLE_MODE) != 0) { 1179 DmaMode |= V_8237_DMA_CHMODE_SINGLE; 1180 } 1181 // 1182 // A Slave DMA transfer can not cross a 64K boundary. 1183 // Compute *NumberOfBytes based on this restriction. 1184 // 1185 MaxNumberOfBytes = 0x10000 - ((UINT32) (*DeviceAddress) & 0xffff); 1186 if (*NumberOfBytes > MaxNumberOfBytes) { 1187 *NumberOfBytes = MaxNumberOfBytes; 1188 } 1189 // 1190 // Compute the values to program into the BaseAddress and Count registers 1191 // of the Slave DMA controller 1192 // 1193 if (ChannelNumber < 4) { 1194 BaseAddress = (UINT32) (*DeviceAddress); 1195 Count = (UINT16) (*NumberOfBytes - 1); 1196 } else { 1197 BaseAddress = (UINT32) (((UINT32) (*DeviceAddress) & 0xff0000) | (((UINT32) (*DeviceAddress) & 0xffff) >> 1)); 1198 Count = (UINT16) ((*NumberOfBytes - 1) >> 1); 1199 } 1200 // 1201 // Program the DMA Write Single Mask Register for ChannelNumber 1202 // Clear the DMA Byte Pointer Register 1203 // 1204 if (ChannelNumber < 4) { 1205 DmaMask = R_8237_DMA_WRSMSK_CH0_3; 1206 DmaClear = R_8237_DMA_CBPR_CH0_3; 1207 DmaChannelMode = R_8237_DMA_CHMODE_CH0_3; 1208 } else { 1209 DmaMask = R_8237_DMA_WRSMSK_CH4_7; 1210 DmaClear = R_8237_DMA_CBPR_CH4_7; 1211 DmaChannelMode = R_8237_DMA_CHMODE_CH4_7; 1212 } 1213 1214 Status = WritePort ( 1215 This, 1216 DmaMask, 1217 (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03)) 1218 ); 1219 if (EFI_ERROR (Status)) { 1220 return Status; 1221 } 1222 1223 Status = WritePort ( 1224 This, 1225 DmaClear, 1226 (UINT8) (B_8237_DMA_WRSMSK_CMS | (ChannelNumber & 0x03)) 1227 ); 1228 if (EFI_ERROR (Status)) { 1229 return Status; 1230 } 1231 1232 Status = WritePort (This, DmaChannelMode, DmaMode); 1233 if (EFI_ERROR (Status)) { 1234 return Status; 1235 } 1236 1237 Status = WriteDmaPort ( 1238 This, 1239 mDmaRegisters[ChannelNumber].Address, 1240 mDmaRegisters[ChannelNumber].Page, 1241 mDmaRegisters[ChannelNumber].Count, 1242 BaseAddress, 1243 Count 1244 ); 1245 if (EFI_ERROR (Status)) { 1246 return Status; 1247 } 1248 1249 Status = WritePort ( 1250 This, 1251 DmaMask, 1252 (UINT8) (ChannelNumber & 0x03) 1253 ); 1254 if (EFI_ERROR (Status)) { 1255 return Status; 1256 } 1257 1258 return EFI_SUCCESS; 1259 } 1260 1261 /** 1262 Maps a memory region for DMA 1263 1264 @param This A pointer to the EFI_ISA_IO_PROTOCOL instance. 1265 @param Operation Indicates the type of DMA (slave or bus master), and if 1266 the DMA operation is going to read or write to system memory. 1267 @param ChannelNumber The slave channel number to use for this DMA operation. 1268 If Operation and ChannelAttributes shows that this device 1269 performs bus mastering DMA, then this field is ignored. 1270 The legal range for this field is 0..7. 1271 @param ChannelAttributes The attributes of the DMA channel to use for this DMA operation 1272 @param HostAddress The system memory address to map to the device. 1273 @param NumberOfBytes On input the number of bytes to map. On output the number 1274 of bytes that were mapped. 1275 @param DeviceAddress The resulting map address for the bus master device to use 1276 to access the hosts HostAddress. 1277 @param Mapping A resulting value to pass to EFI_ISA_IO.Unmap(). 1278 1279 @retval EFI_SUCCESS The range was mapped for the returned NumberOfBytes. 1280 @retval EFI_INVALID_PARAMETER The Operation or HostAddress is undefined. 1281 @retval EFI_UNSUPPORTED The HostAddress can not be mapped as a common buffer. 1282 @retval EFI_DEVICE_ERROR The system hardware could not map the requested address. 1283 @retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated. 1284 **/ 1285 EFI_STATUS 1286 EFIAPI 1287 IsaIoMap ( 1288 IN EFI_ISA_IO_PROTOCOL *This, 1289 IN EFI_ISA_IO_PROTOCOL_OPERATION Operation, 1290 IN UINT8 ChannelNumber OPTIONAL, 1291 IN UINT32 ChannelAttributes, 1292 IN VOID *HostAddress, 1293 IN OUT UINTN *NumberOfBytes, 1294 OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, 1295 OUT VOID **Mapping 1296 ) 1297 { 1298 // 1299 // Check if DMA is supported. 1300 // 1301 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) { 1302 return EFI_UNSUPPORTED; 1303 } 1304 // 1305 // Set Feature Flag PcdIsaBusSupportBusMaster to FALSE to disable support for 1306 // ISA Bus Master. 1307 // 1308 // So we just return EFI_UNSUPPORTED for these functions. 1309 // 1310 if ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0) { 1311 return IsaIoMapOnlySupportSlaveReadWrite ( 1312 This, 1313 Operation, 1314 ChannelNumber, 1315 ChannelAttributes, 1316 HostAddress, 1317 NumberOfBytes, 1318 DeviceAddress, 1319 Mapping 1320 ); 1321 1322 } else { 1323 return IsaIoMapFullSupport ( 1324 This, 1325 Operation, 1326 ChannelNumber, 1327 ChannelAttributes, 1328 HostAddress, 1329 NumberOfBytes, 1330 DeviceAddress, 1331 Mapping 1332 ); 1333 } 1334 } 1335 1336 /** 1337 Allocates pages that are suitable for an EfiIsaIoOperationBusMasterCommonBuffer mapping. 1338 1339 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 1340 @param[in] Type The type allocation to perform. 1341 @param[in] MemoryType The type of memory to allocate. 1342 @param[in] Pages The number of pages to allocate. 1343 @param[out] HostAddress A pointer to store the base address of the allocated range. 1344 @param[in] Attributes The requested bit mask of attributes for the allocated range. 1345 1346 @retval EFI_SUCCESS The requested memory pages were allocated. 1347 @retval EFI_INVALID_PARAMETER Type is invalid or MemoryType is invalid or HostAddress is NULL 1348 @retval EFI_UNSUPPORTED Attributes is unsupported or the memory range specified 1349 by HostAddress, Pages, and Type is not available for common buffer use. 1350 @retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated. 1351 **/ 1352 EFI_STATUS 1353 EFIAPI 1354 IsaIoAllocateBuffer ( 1355 IN EFI_ISA_IO_PROTOCOL *This, 1356 IN EFI_ALLOCATE_TYPE Type, 1357 IN EFI_MEMORY_TYPE MemoryType, 1358 IN UINTN Pages, 1359 OUT VOID **HostAddress, 1360 IN UINT64 Attributes 1361 ) 1362 { 1363 EFI_STATUS Status; 1364 EFI_PHYSICAL_ADDRESS PhysicalAddress; 1365 1366 // 1367 // Set Feature Flag PcdIsaBusOnlySupportSlaveDma to FALSE to disable support for 1368 // ISA Bus Master. 1369 // Or unset Feature Flag PcdIsaBusSupportDma to disable support for ISA DMA. 1370 // 1371 if (((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) || 1372 ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0)) { 1373 return EFI_UNSUPPORTED; 1374 } 1375 1376 if (HostAddress == NULL) { 1377 return EFI_INVALID_PARAMETER; 1378 } 1379 1380 if ((UINT32)Type >= MaxAllocateType) { 1381 return EFI_INVALID_PARAMETER; 1382 } 1383 // 1384 // The only valid memory types are EfiBootServicesData and EfiRuntimeServicesData 1385 // 1386 if (MemoryType != EfiBootServicesData && MemoryType != EfiRuntimeServicesData) { 1387 return EFI_INVALID_PARAMETER; 1388 } 1389 1390 if ((Attributes & ~(EFI_ISA_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE | EFI_ISA_IO_ATTRIBUTE_MEMORY_CACHED)) != 0) { 1391 return EFI_UNSUPPORTED; 1392 } 1393 1394 PhysicalAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) (ISA_MAX_MEMORY_ADDRESS - 1); 1395 if (Type == AllocateAddress) { 1396 if ((UINTN) (*HostAddress) >= ISA_MAX_MEMORY_ADDRESS) { 1397 return EFI_UNSUPPORTED; 1398 } else { 1399 PhysicalAddress = (UINTN) (*HostAddress); 1400 } 1401 } 1402 1403 if (Type == AllocateAnyPages) { 1404 Type = AllocateMaxAddress; 1405 } 1406 1407 Status = gBS->AllocatePages (Type, MemoryType, Pages, &PhysicalAddress); 1408 if (EFI_ERROR (Status)) { 1409 REPORT_STATUS_CODE ( 1410 EFI_ERROR_CODE | EFI_ERROR_MINOR, 1411 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 1412 ); 1413 return Status; 1414 } 1415 1416 *HostAddress = (VOID *) (UINTN) PhysicalAddress; 1417 return Status; 1418 } 1419 1420 /** 1421 Frees memory that was allocated with EFI_ISA_IO.AllocateBuffer(). 1422 1423 @param[in] This A pointer to the EFI_ISA_IO_PROTOCOL instance. 1424 @param[in] Pages The number of pages to free. 1425 @param[in] HostAddress The base address of the allocated range. 1426 1427 @retval EFI_SUCCESS The requested memory pages were freed. 1428 @retval EFI_INVALID_PARAMETER The memory was not allocated with EFI_ISA_IO.AllocateBufer(). 1429 **/ 1430 EFI_STATUS 1431 EFIAPI 1432 IsaIoFreeBuffer ( 1433 IN EFI_ISA_IO_PROTOCOL *This, 1434 IN UINTN Pages, 1435 IN VOID *HostAddress 1436 ) 1437 { 1438 EFI_STATUS Status; 1439 1440 // 1441 // Set Feature Flag PcdIsaBusOnlySupportSlaveDma to FALSE to disable support for 1442 // ISA Bus Master. 1443 // Or unset Feature Flag PcdIsaBusSupportDma to disable support for ISA DMA. 1444 // 1445 if (((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_SUPPORT_DMA) == 0) || 1446 ((PcdGet8 (PcdIsaBusSupportedFeatures) & PCD_ISA_BUS_ONLY_SUPPORT_SLAVE_DMA) != 0)) { 1447 return EFI_UNSUPPORTED; 1448 } 1449 1450 Status = gBS->FreePages ( 1451 (EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress, 1452 Pages 1453 ); 1454 if (EFI_ERROR (Status)) { 1455 REPORT_STATUS_CODE ( 1456 EFI_ERROR_CODE | EFI_ERROR_MINOR, 1457 EFI_IO_BUS_LPC | EFI_IOB_EC_CONTROLLER_ERROR 1458 ); 1459 } 1460 1461 return Status; 1462 } 1463 1464
