1 /** @file 2 The implementation for EFI_ISA_IO_PROTOCOL. 3 4 Copyright (c) 2010 - 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 "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 1804
