1 /** @file 2 This file implement UEFI driver for IDE Bus which includes device identification, 3 Child device(Disk, CDROM, etc) enumeration and child handler installation, and 4 driver stop. 5 6 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR> 7 This program and the accompanying materials 8 are licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 @par Revision Reference: 16 This module is modified from DXE\IDE module for Ide Contriller Init support 17 18 **/ 19 20 #include "IdeBus.h" 21 22 #define PCI_CLASS_MASS_STORAGE 0x01 23 #define PCI_SUB_CLASS_IDE 0x01 24 25 26 // 27 // IDE Bus Driver Binding Protocol Instance 28 // 29 EFI_DRIVER_BINDING_PROTOCOL gIDEBusDriverBinding = { 30 IDEBusDriverBindingSupported, 31 IDEBusDriverBindingStart, 32 IDEBusDriverBindingStop, 33 0xa, 34 NULL, 35 NULL 36 }; 37 /** 38 Deregister an IDE device and free resources 39 40 @param This Protocol instance pointer. 41 @param Controller Ide device handle 42 @param Handle Handle of device to deregister driver on 43 44 @retval EFI_SUCCESS Deregiter a specific IDE device successfully 45 46 47 **/ 48 EFI_STATUS 49 DeRegisterIdeDevice ( 50 IN EFI_DRIVER_BINDING_PROTOCOL *This, 51 IN EFI_HANDLE Controller, 52 IN EFI_HANDLE Handle 53 ) 54 { 55 EFI_STATUS Status; 56 EFI_BLOCK_IO_PROTOCOL *BlkIo; 57 IDE_BLK_IO_DEV *IdeBlkIoDevice; 58 EFI_PCI_IO_PROTOCOL *PciIo; 59 UINTN Index; 60 61 Status = gBS->OpenProtocol ( 62 Handle, 63 &gEfiBlockIoProtocolGuid, 64 (VOID **) &BlkIo, 65 This->DriverBindingHandle, 66 Controller, 67 EFI_OPEN_PROTOCOL_GET_PROTOCOL 68 ); 69 if (EFI_ERROR (Status)) { 70 return Status; 71 } 72 73 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (BlkIo); 74 75 // 76 // Report Status code: Device disabled 77 // 78 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 79 EFI_PROGRESS_CODE, 80 (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_DISABLE), 81 IdeBlkIoDevice->DevicePath 82 ); 83 84 // 85 // Close the child handle 86 // 87 Status = gBS->CloseProtocol ( 88 Controller, 89 &gEfiPciIoProtocolGuid, 90 This->DriverBindingHandle, 91 Handle 92 ); 93 94 Status = gBS->UninstallMultipleProtocolInterfaces ( 95 Handle, 96 &gEfiDevicePathProtocolGuid, 97 IdeBlkIoDevice->DevicePath, 98 &gEfiBlockIoProtocolGuid, 99 &IdeBlkIoDevice->BlkIo, 100 &gEfiDiskInfoProtocolGuid, 101 &IdeBlkIoDevice->DiskInfo, 102 NULL 103 ); 104 105 if (EFI_ERROR (Status)) { 106 gBS->OpenProtocol ( 107 Controller, 108 &gEfiPciIoProtocolGuid, 109 (VOID **) &PciIo, 110 This->DriverBindingHandle, 111 Handle, 112 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 113 ); 114 return Status; 115 } 116 117 // 118 // Release allocated resources 119 // 120 Index = IdeBlkIoDevice->Channel * 2 + IdeBlkIoDevice->Device; 121 if (Index < MAX_IDE_DEVICE) { 122 IdeBlkIoDevice->IdeBusDriverPrivateData->HaveScannedDevice[Index] = FALSE; 123 } 124 ReleaseIdeResources (IdeBlkIoDevice); 125 126 return EFI_SUCCESS; 127 } 128 /** 129 Supported function of Driver Binding protocol for this driver. 130 131 @param This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 132 @param ControllerHandle The handle of the controller to test. 133 @param RemainingDevicePath A pointer to the remaining portion of a device path. 134 135 @retval EFI_SUCCESS Driver loaded. 136 @retval other Driver not loaded. 137 138 **/ 139 EFI_STATUS 140 EFIAPI 141 IDEBusDriverBindingSupported ( 142 IN EFI_DRIVER_BINDING_PROTOCOL *This, 143 IN EFI_HANDLE Controller, 144 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 145 ) 146 { 147 EFI_STATUS Status; 148 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; 149 EFI_DEV_PATH *Node; 150 EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit; 151 EFI_PCI_IO_PROTOCOL *PciIo; 152 PCI_TYPE00 PciData; 153 154 if (RemainingDevicePath != NULL) { 155 Node = (EFI_DEV_PATH *) RemainingDevicePath; 156 // 157 // Check if RemainingDevicePath is the End of Device Path Node, 158 // if yes, go on checking other conditions 159 // 160 if (!IsDevicePathEnd (Node)) { 161 // 162 // If RemainingDevicePath isn't the End of Device Path Node, 163 // check its validation 164 // 165 if (Node->DevPath.Type != MESSAGING_DEVICE_PATH || 166 Node->DevPath.SubType != MSG_ATAPI_DP || 167 DevicePathNodeLength(&Node->DevPath) != sizeof(ATAPI_DEVICE_PATH)) { 168 return EFI_UNSUPPORTED; 169 } 170 } 171 } 172 173 // 174 // Verify the Ide Controller Init Protocol, which installed by the 175 // IdeController module. 176 // 177 Status = gBS->OpenProtocol ( 178 Controller, 179 &gEfiIdeControllerInitProtocolGuid, 180 (VOID **) &IdeInit, 181 This->DriverBindingHandle, 182 Controller, 183 EFI_OPEN_PROTOCOL_BY_DRIVER 184 ); 185 186 if (Status == EFI_ALREADY_STARTED) { 187 return EFI_SUCCESS; 188 } 189 190 if (EFI_ERROR (Status)) { 191 return Status; 192 } 193 194 // 195 // Close the I/O Abstraction(s) used to perform the supported test 196 // 197 gBS->CloseProtocol ( 198 Controller, 199 &gEfiIdeControllerInitProtocolGuid, 200 This->DriverBindingHandle, 201 Controller 202 ); 203 204 // 205 // Open the EFI Device Path protocol needed to perform the supported test 206 // 207 Status = gBS->OpenProtocol ( 208 Controller, 209 &gEfiDevicePathProtocolGuid, 210 (VOID **) &ParentDevicePath, 211 This->DriverBindingHandle, 212 Controller, 213 EFI_OPEN_PROTOCOL_BY_DRIVER 214 ); 215 if (Status == EFI_ALREADY_STARTED) { 216 return EFI_SUCCESS; 217 } 218 219 // 220 // Close protocol, don't use device path protocol in the Support() function 221 // 222 gBS->CloseProtocol ( 223 Controller, 224 &gEfiDevicePathProtocolGuid, 225 This->DriverBindingHandle, 226 Controller 227 ); 228 229 // 230 // Get the EfiPciIoProtocol 231 // 232 Status = gBS->OpenProtocol ( 233 Controller, 234 &gEfiPciIoProtocolGuid, 235 (VOID **) &PciIo, 236 This->DriverBindingHandle, 237 Controller, 238 EFI_OPEN_PROTOCOL_GET_PROTOCOL 239 ); 240 241 if (EFI_ERROR (Status)) { 242 return Status; 243 } 244 245 // 246 // Now further check the PCI header: Base class (offset 0x0B) and 247 // Sub Class (offset 0x0A). This controller should be an IDE controller 248 // 249 Status = PciIo->Pci.Read ( 250 PciIo, 251 EfiPciIoWidthUint8, 252 0, 253 sizeof (PciData), 254 &PciData 255 ); 256 257 if (!EFI_ERROR (Status)) { 258 // 259 // Examine if it is IDE mode by class code 260 // 261 if ((PciData.Hdr.ClassCode[2] != PCI_CLASS_MASS_STORAGE) || (PciData.Hdr.ClassCode[1] != PCI_SUB_CLASS_IDE)) { 262 Status = EFI_UNSUPPORTED; 263 } else { 264 Status = EFI_SUCCESS; 265 } 266 } 267 268 return Status; 269 } 270 271 272 /** 273 Start function of Driver binding protocol which start this driver on Controller 274 by detecting all disks and installing BlockIo protocol on them. 275 276 @param This Protocol instance pointer. 277 @param Controller Handle of device to bind driver to. 278 @param RemainingDevicePath produce all possible children. 279 280 @retval EFI_SUCCESS This driver is added to ControllerHandle. 281 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle. 282 @retval other This driver does not support this device. 283 284 **/ 285 EFI_STATUS 286 EFIAPI 287 IDEBusDriverBindingStart ( 288 IN EFI_DRIVER_BINDING_PROTOCOL *This, 289 IN EFI_HANDLE Controller, 290 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 291 ) 292 { 293 EFI_STATUS Status; 294 EFI_STATUS SavedStatus; 295 EFI_PCI_IO_PROTOCOL *PciIo; 296 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; 297 EFI_DEV_PATH *Node; 298 UINT8 IdeChannel; 299 UINT8 BeginningIdeChannel; 300 UINT8 EndIdeChannel; 301 UINT8 IdeDevice; 302 UINT8 BeginningIdeDevice; 303 UINT8 EndIdeDevice; 304 IDE_BLK_IO_DEV *IdeBlkIoDevice[IdeMaxChannel][IdeMaxDevice]; 305 IDE_BLK_IO_DEV *IdeBlkIoDevicePtr; 306 IDE_REGISTERS_BASE_ADDR IdeRegsBaseAddr[IdeMaxChannel]; 307 ATA_TRANSFER_MODE TransferMode; 308 ATA_DRIVE_PARMS DriveParameters; 309 EFI_DEV_PATH NewNode; 310 UINT8 ConfigurationOptions; 311 UINT16 CommandBlockBaseAddr; 312 UINT16 ControlBlockBaseAddr; 313 UINTN DataSize; 314 IDE_BUS_DRIVER_PRIVATE_DATA *IdeBusDriverPrivateData; 315 UINT64 Supports; 316 317 // 318 // Local variables declaration for IdeControllerInit support 319 // 320 EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit; 321 BOOLEAN EnumAll; 322 BOOLEAN ChannelEnabled; 323 UINT8 MaxDevices; 324 EFI_IDENTIFY_DATA IdentifyData; 325 EFI_ATA_COLLECTIVE_MODE *SupportedModes; 326 327 IdeBusDriverPrivateData = NULL; 328 SupportedModes = NULL; 329 330 // 331 // Perform IdeBus initialization 332 // 333 Status = gBS->OpenProtocol ( 334 Controller, 335 &gEfiDevicePathProtocolGuid, 336 (VOID **) &ParentDevicePath, 337 This->DriverBindingHandle, 338 Controller, 339 EFI_OPEN_PROTOCOL_BY_DRIVER 340 ); 341 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) { 342 return Status; 343 } 344 345 // 346 // Now open the IDE_CONTROLLER_INIT protocol. Step7.1 347 // 348 Status = gBS->OpenProtocol ( 349 Controller, 350 &gEfiIdeControllerInitProtocolGuid, 351 (VOID **) &IdeInit, 352 This->DriverBindingHandle, 353 Controller, 354 EFI_OPEN_PROTOCOL_BY_DRIVER 355 ); 356 357 // 358 // The following OpenProtocol function with _GET_PROTOCOL attribute and 359 // will not return EFI_ALREADY_STARTED, so save it for now 360 // 361 SavedStatus = Status; 362 363 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) { 364 DEBUG ((EFI_D_ERROR, "Open Init, Status=%x", Status)); 365 // 366 // open protocol is not SUCCESS or not ALREADY_STARTED, error exit 367 // 368 goto ErrorExit; 369 } 370 371 // 372 // Save Enumall. Step7.2 373 // 374 EnumAll = IdeInit->EnumAll; 375 376 // 377 // Consume PCI I/O protocol. Note that the OpenProtocol with _GET_PROTOCOL 378 // attribute will not return EFI_ALREADY_STARTED 379 // 380 Status = gBS->OpenProtocol ( 381 Controller, 382 &gEfiPciIoProtocolGuid, 383 (VOID **) &PciIo, 384 This->DriverBindingHandle, 385 Controller, 386 EFI_OPEN_PROTOCOL_GET_PROTOCOL 387 ); 388 if (EFI_ERROR (Status)) { 389 DEBUG ((EFI_D_ERROR, "Open PciIo, Status=%x", Status)); 390 goto ErrorExit; 391 } 392 393 // 394 // We must check EFI_ALREADY_STARTED because many ATAPI devices are removable 395 // 396 if (SavedStatus != EFI_ALREADY_STARTED) { 397 IdeBusDriverPrivateData = AllocatePool (sizeof (IDE_BUS_DRIVER_PRIVATE_DATA)); 398 if (IdeBusDriverPrivateData == NULL) { 399 Status = EFI_OUT_OF_RESOURCES; 400 goto ErrorExit; 401 } 402 403 ZeroMem (IdeBusDriverPrivateData, sizeof (IDE_BUS_DRIVER_PRIVATE_DATA)); 404 Status = gBS->InstallMultipleProtocolInterfaces ( 405 &Controller, 406 &gEfiCallerIdGuid, 407 IdeBusDriverPrivateData, 408 NULL 409 ); 410 if (EFI_ERROR (Status)) { 411 goto ErrorExit; 412 } 413 414 } else { 415 Status = gBS->OpenProtocol ( 416 Controller, 417 &gEfiCallerIdGuid, 418 (VOID **) &IdeBusDriverPrivateData, 419 This->DriverBindingHandle, 420 Controller, 421 EFI_OPEN_PROTOCOL_GET_PROTOCOL 422 ); 423 if (EFI_ERROR (Status)) { 424 IdeBusDriverPrivateData = NULL; 425 goto ErrorExit; 426 } 427 } 428 429 Status = PciIo->Attributes ( 430 PciIo, 431 EfiPciIoAttributeOperationSupported, 432 0, 433 &Supports 434 ); 435 if (!EFI_ERROR (Status)) { 436 Supports &= (UINT64)EFI_PCI_DEVICE_ENABLE; 437 Status = PciIo->Attributes ( 438 PciIo, 439 EfiPciIoAttributeOperationEnable, 440 Supports, 441 NULL 442 ); 443 } 444 445 if (EFI_ERROR (Status)) { 446 goto ErrorExit; 447 } 448 449 // 450 // Read the environment variable that contains the IDEBus Driver's 451 // Config options that were set by the Driver Configuration Protocol 452 // 453 DataSize = sizeof (ConfigurationOptions); 454 Status = gRT->GetVariable ( 455 (CHAR16 *) L"Configuration", 456 &gEfiCallerIdGuid, 457 NULL, 458 &DataSize, 459 &ConfigurationOptions 460 ); 461 if (EFI_ERROR (Status)) { 462 ConfigurationOptions = 0x0f; 463 } 464 465 if (EnumAll || RemainingDevicePath == NULL) { 466 // 467 // If IdeInit->EnumAll is TRUE or RemainingDevicePath is NULL, 468 // must enumerate all IDE devices anyway 469 // 470 BeginningIdeChannel = IdePrimary; 471 EndIdeChannel = IdeSecondary; 472 BeginningIdeDevice = IdeMaster; 473 EndIdeDevice = IdeSlave; 474 475 } else if (!IsDevicePathEnd (RemainingDevicePath)) { 476 // 477 // If RemainingDevicePath isn't the End of Device Path Node, 478 // only scan the specified device by RemainingDevicePath 479 // 480 Node = (EFI_DEV_PATH *) RemainingDevicePath; 481 BeginningIdeChannel = Node->Atapi.PrimarySecondary; 482 EndIdeChannel = BeginningIdeChannel; 483 BeginningIdeDevice = Node->Atapi.SlaveMaster; 484 EndIdeDevice = BeginningIdeDevice; 485 if (BeginningIdeChannel >= IdeMaxChannel || EndIdeChannel >= IdeMaxChannel) { 486 Status = EFI_INVALID_PARAMETER; 487 goto ErrorExit; 488 } 489 if (BeginningIdeDevice >= IdeMaxDevice|| EndIdeDevice >= IdeMaxDevice) { 490 Status = EFI_INVALID_PARAMETER; 491 goto ErrorExit; 492 } 493 494 } else { 495 // 496 // If RemainingDevicePath is the End of Device Path Node, 497 // skip enumerate any device and return EFI_SUCESSS 498 // 499 BeginningIdeChannel = IdeMaxChannel; 500 EndIdeChannel = IdeMaxChannel - 1; 501 BeginningIdeDevice = IdeMaxDevice; 502 EndIdeDevice = IdeMaxDevice - 1; 503 } 504 505 // 506 // Obtain IDE IO port registers' base addresses 507 // 508 Status = GetIdeRegistersBaseAddr (PciIo, IdeRegsBaseAddr); 509 if (EFI_ERROR (Status)) { 510 goto ErrorExit; 511 } 512 513 // 514 // Report status code: begin IdeBus initialization 515 // 516 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 517 EFI_PROGRESS_CODE, 518 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_RESET), 519 ParentDevicePath 520 ); 521 522 // 523 // Strictly follow the enumeration based on IDE_CONTROLLER_INIT protocol 524 // 525 for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) { 526 527 IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelEnumeration, IdeChannel); 528 529 // 530 // now obtain channel information fron IdeControllerInit protocol. Step9 531 // 532 Status = IdeInit->GetChannelInfo ( 533 IdeInit, 534 IdeChannel, 535 &ChannelEnabled, 536 &MaxDevices 537 ); 538 if (EFI_ERROR (Status)) { 539 DEBUG ((EFI_D_ERROR, "[GetChannel, Status=%x]", Status)); 540 continue; 541 } 542 543 if (!ChannelEnabled) { 544 continue; 545 } 546 547 EndIdeDevice = (UINT8) MIN ((MaxDevices - 1), EndIdeDevice); 548 ASSERT (EndIdeDevice < IdeMaxDevice); 549 // 550 // Now inform the IDE Controller Init Module. Sept10 551 // 552 IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelReset, IdeChannel); 553 554 // 555 // No reset channel function implemented. Sept11 556 // 557 IdeInit->NotifyPhase (IdeInit, EfiIdeAfterChannelReset, IdeChannel); 558 559 // 560 // Step13 561 // 562 IdeInit->NotifyPhase ( 563 IdeInit, 564 EfiIdeBusBeforeDevicePresenceDetection, 565 IdeChannel 566 ); 567 568 // 569 // Prepare to detect IDE device of this channel 570 // 571 InitializeIDEChannelData (); 572 573 // 574 // -- 1st inner loop --- Master/Slave ------------ Step14 575 // 576 for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) { 577 // 578 // Check whether the configuration options allow this device 579 // 580 if ((ConfigurationOptions & (1 << (IdeChannel * 2 + IdeDevice))) == 0) { 581 continue; 582 } 583 584 // 585 // The device has been scanned in another Start(), No need to scan it again 586 // for perf optimization. 587 // 588 if (IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice]) { 589 continue; 590 } 591 592 // 593 // create child handle for the detected device. 594 // 595 IdeBlkIoDevice[IdeChannel][IdeDevice] = AllocatePool (sizeof (IDE_BLK_IO_DEV)); 596 if (IdeBlkIoDevice[IdeChannel][IdeDevice] == NULL) { 597 continue; 598 } 599 600 IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice]; 601 602 ZeroMem (IdeBlkIoDevicePtr, sizeof (IDE_BLK_IO_DEV)); 603 604 IdeBlkIoDevicePtr->Signature = IDE_BLK_IO_DEV_SIGNATURE; 605 IdeBlkIoDevicePtr->Channel = (EFI_IDE_CHANNEL) IdeChannel; 606 IdeBlkIoDevicePtr->Device = (EFI_IDE_DEVICE) IdeDevice; 607 608 // 609 // initialize Block IO interface's Media pointer 610 // 611 IdeBlkIoDevicePtr->BlkIo.Media = &IdeBlkIoDevicePtr->BlkMedia; 612 613 // 614 // Initialize IDE IO port addresses, including Command Block registers 615 // and Control Block registers 616 // 617 IdeBlkIoDevicePtr->IoPort = AllocatePool (sizeof (IDE_BASE_REGISTERS)); 618 if (IdeBlkIoDevicePtr->IoPort == NULL) { 619 continue; 620 } 621 622 ZeroMem (IdeBlkIoDevicePtr->IoPort, sizeof (IDE_BASE_REGISTERS)); 623 CommandBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].CommandBlockBaseAddr; 624 ControlBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].ControlBlockBaseAddr; 625 626 IdeBlkIoDevicePtr->IoPort->Data = CommandBlockBaseAddr; 627 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg1) = (UINT16) (CommandBlockBaseAddr + 0x01); 628 IdeBlkIoDevicePtr->IoPort->SectorCount = (UINT16) (CommandBlockBaseAddr + 0x02); 629 IdeBlkIoDevicePtr->IoPort->SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x03); 630 IdeBlkIoDevicePtr->IoPort->CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x04); 631 IdeBlkIoDevicePtr->IoPort->CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x05); 632 IdeBlkIoDevicePtr->IoPort->Head = (UINT16) (CommandBlockBaseAddr + 0x06); 633 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg) = (UINT16) (CommandBlockBaseAddr + 0x07); 634 635 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Alt) = ControlBlockBaseAddr; 636 IdeBlkIoDevicePtr->IoPort->DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x01); 637 638 IdeBlkIoDevicePtr->IoPort->MasterSlave = (UINT16) ((IdeDevice == IdeMaster) ? 1 : 0); 639 640 IdeBlkIoDevicePtr->PciIo = PciIo; 641 IdeBlkIoDevicePtr->IdeBusDriverPrivateData = IdeBusDriverPrivateData; 642 IdeBlkIoDevicePtr->IoPort->BusMasterBaseAddr = IdeRegsBaseAddr[IdeChannel].BusMasterBaseAddr; 643 644 // 645 // Report Status code: is about to detect IDE drive 646 // 647 REPORT_STATUS_CODE_EX ( 648 EFI_PROGRESS_CODE, 649 (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_PRESENCE_DETECT), 650 0, 651 &gEfiCallerIdGuid, 652 NULL, 653 NULL, 654 0 655 ); 656 657 // 658 // Discover device, now! 659 // 660 PERF_START (NULL, "DiscoverIdeDevice", "IDE", 0); 661 Status = DiscoverIdeDevice (IdeBlkIoDevicePtr); 662 PERF_END (NULL, "DiscoverIdeDevice", "IDE", 0); 663 664 IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice] = TRUE; 665 IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice] = FALSE; 666 667 if (!EFI_ERROR (Status)) { 668 // 669 // Set Device Path 670 // 671 ZeroMem (&NewNode, sizeof (NewNode)); 672 NewNode.DevPath.Type = MESSAGING_DEVICE_PATH; 673 NewNode.DevPath.SubType = MSG_ATAPI_DP; 674 SetDevicePathNodeLength (&NewNode.DevPath, sizeof (ATAPI_DEVICE_PATH)); 675 676 NewNode.Atapi.PrimarySecondary = (UINT8) IdeBlkIoDevicePtr->Channel; 677 NewNode.Atapi.SlaveMaster = (UINT8) IdeBlkIoDevicePtr->Device; 678 NewNode.Atapi.Lun = IdeBlkIoDevicePtr->Lun; 679 IdeBlkIoDevicePtr->DevicePath = AppendDevicePathNode ( 680 ParentDevicePath, 681 &NewNode.DevPath 682 ); 683 if (IdeBlkIoDevicePtr->DevicePath == NULL) { 684 ReleaseIdeResources (IdeBlkIoDevicePtr); 685 continue; 686 } 687 688 // 689 // Submit identify data to IDE controller init driver 690 // 691 CopyMem (&IdentifyData, IdeBlkIoDevicePtr->IdData, sizeof (IdentifyData)); 692 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = TRUE; 693 IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, &IdentifyData); 694 } else { 695 // 696 // Device detection failed 697 // 698 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE; 699 IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, NULL); 700 ReleaseIdeResources (IdeBlkIoDevicePtr); 701 IdeBlkIoDevicePtr = NULL; 702 } 703 // 704 // end of 1st inner loop --- 705 // 706 } 707 // 708 // end of 1st outer loop ========= 709 // 710 } 711 712 // 713 // = 2nd outer loop == Primary/Secondary ================= 714 // 715 for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) { 716 717 // 718 // -- 2nd inner loop --- Master/Slave -------- 719 // 720 for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) { 721 722 ASSERT (IdeChannel * 2 + IdeDevice < MAX_IDE_DEVICE); 723 if (IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice]) { 724 continue; 725 } 726 727 if (!IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice]) { 728 continue; 729 } 730 731 Status = IdeInit->CalculateMode ( 732 IdeInit, 733 IdeChannel, 734 IdeDevice, 735 &SupportedModes 736 ); 737 if (EFI_ERROR (Status)) { 738 DEBUG ((EFI_D_ERROR, "[bStStp20S=%x]", Status)); 739 continue; 740 } 741 742 ASSERT (IdeChannel < IdeMaxChannel && IdeDevice < IdeMaxDevice); 743 IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice]; 744 745 // 746 // Set best supported PIO mode on this IDE device 747 // 748 if (SupportedModes->PioMode.Mode <= AtaPioMode2) { 749 TransferMode.ModeCategory = ATA_MODE_CATEGORY_DEFAULT_PIO; 750 } else { 751 TransferMode.ModeCategory = ATA_MODE_CATEGORY_FLOW_PIO; 752 } 753 754 TransferMode.ModeNumber = (UINT8) (SupportedModes->PioMode.Mode); 755 756 if (SupportedModes->ExtModeCount == 0){ 757 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode); 758 759 if (EFI_ERROR (Status)) { 760 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE; 761 ReleaseIdeResources (IdeBlkIoDevicePtr); 762 IdeBlkIoDevicePtr = NULL; 763 continue; 764 } 765 } 766 767 // 768 // Set supported DMA mode on this IDE device. Note that UDMA & MDMA cann't 769 // be set together. Only one DMA mode can be set to a device. If setting 770 // DMA mode operation fails, we can continue moving on because we only use 771 // PIO mode at boot time. DMA modes are used by certain kind of OS booting 772 // 773 if (SupportedModes->UdmaMode.Valid) { 774 775 TransferMode.ModeCategory = ATA_MODE_CATEGORY_UDMA; 776 TransferMode.ModeNumber = (UINT8) (SupportedModes->UdmaMode.Mode); 777 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode); 778 779 if (EFI_ERROR (Status)) { 780 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE; 781 ReleaseIdeResources (IdeBlkIoDevicePtr); 782 IdeBlkIoDevicePtr = NULL; 783 continue; 784 } 785 // 786 // Record Udma Mode 787 // 788 IdeBlkIoDevicePtr->UdmaMode.Valid = TRUE; 789 IdeBlkIoDevicePtr->UdmaMode.Mode = SupportedModes->UdmaMode.Mode; 790 EnableInterrupt (IdeBlkIoDevicePtr); 791 } else if (SupportedModes->MultiWordDmaMode.Valid) { 792 793 TransferMode.ModeCategory = ATA_MODE_CATEGORY_MDMA; 794 TransferMode.ModeNumber = (UINT8) SupportedModes->MultiWordDmaMode.Mode; 795 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode); 796 797 if (EFI_ERROR (Status)) { 798 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE; 799 ReleaseIdeResources (IdeBlkIoDevicePtr); 800 IdeBlkIoDevicePtr = NULL; 801 continue; 802 } 803 804 EnableInterrupt (IdeBlkIoDevicePtr); 805 } 806 // 807 // Init driver parameters 808 // 809 DriveParameters.Sector = (UINT8) ((ATA5_IDENTIFY_DATA *) IdeBlkIoDevicePtr->IdData)->sectors_per_track; 810 DriveParameters.Heads = (UINT8) (((ATA5_IDENTIFY_DATA *) IdeBlkIoDevicePtr->IdData)->heads - 1); 811 DriveParameters.MultipleSector = (UINT8) IdeBlkIoDevicePtr->IdData->AtaData.multi_sector_cmd_max_sct_cnt; 812 // 813 // Set Parameters for the device: 814 // 1) Init 815 // 2) Establish the block count for READ/WRITE MULTIPLE (EXT) command 816 // 817 if ((IdeBlkIoDevicePtr->Type == IdeHardDisk) || (IdeBlkIoDevicePtr->Type == Ide48bitAddressingHardDisk)) { 818 Status = SetDriveParameters (IdeBlkIoDevicePtr, &DriveParameters); 819 } 820 821 // 822 // Record PIO mode used in private data 823 // 824 IdeBlkIoDevicePtr->PioMode = (ATA_PIO_MODE) SupportedModes->PioMode.Mode; 825 826 // 827 // Set IDE controller Timing Blocks in the PCI Configuration Space 828 // 829 IdeInit->SetTiming (IdeInit, IdeChannel, IdeDevice, SupportedModes); 830 831 // 832 // Add Component Name for the IDE/ATAPI device that was discovered. 833 // 834 IdeBlkIoDevicePtr->ControllerNameTable = NULL; 835 ADD_IDE_ATAPI_NAME (IdeBlkIoDevicePtr); 836 837 Status = gBS->InstallMultipleProtocolInterfaces ( 838 &IdeBlkIoDevicePtr->Handle, 839 &gEfiDevicePathProtocolGuid, 840 IdeBlkIoDevicePtr->DevicePath, 841 &gEfiBlockIoProtocolGuid, 842 &IdeBlkIoDevicePtr->BlkIo, 843 &gEfiDiskInfoProtocolGuid, 844 &IdeBlkIoDevicePtr->DiskInfo, 845 NULL 846 ); 847 848 if (EFI_ERROR (Status)) { 849 ReleaseIdeResources (IdeBlkIoDevicePtr); 850 } 851 852 gBS->OpenProtocol ( 853 Controller, 854 &gEfiPciIoProtocolGuid, 855 (VOID **) &PciIo, 856 This->DriverBindingHandle, 857 IdeBlkIoDevicePtr->Handle, 858 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 859 ); 860 861 IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice] = TRUE; 862 863 // 864 // Report status code: device eanbled! 865 // 866 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 867 EFI_PROGRESS_CODE, 868 (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_ENABLE), 869 IdeBlkIoDevicePtr->DevicePath 870 ); 871 872 // 873 // Create event to clear pending IDE interrupt 874 // 875 Status = gBS->CreateEventEx ( 876 EVT_NOTIFY_SIGNAL, 877 TPL_NOTIFY, 878 ClearInterrupt, 879 IdeBlkIoDevicePtr, 880 &gEfiEventExitBootServicesGuid, 881 &IdeBlkIoDevicePtr->ExitBootServiceEvent 882 ); 883 884 // 885 // end of 2nd inner loop ---- 886 // 887 } 888 // 889 // end of 2nd outer loop ========== 890 // 891 } 892 893 // 894 // All configurations done! Notify IdeController to do post initialization 895 // work such as saving IDE controller PCI settings for S3 resume 896 // 897 IdeInit->NotifyPhase (IdeInit, EfiIdeBusPhaseMaximum, 0); 898 899 if (SupportedModes != NULL) { 900 FreePool (SupportedModes); 901 } 902 903 PERF_START (NULL, "Finish IDE detection", "IDE", 1); 904 PERF_END (NULL, "Finish IDE detection", "IDE", 0); 905 906 return EFI_SUCCESS; 907 908 ErrorExit: 909 910 // 911 // Report error code: controller error 912 // 913 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 914 EFI_ERROR_CODE | EFI_ERROR_MINOR, 915 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_EC_CONTROLLER_ERROR), 916 ParentDevicePath 917 ); 918 919 gBS->CloseProtocol ( 920 Controller, 921 &gEfiIdeControllerInitProtocolGuid, 922 This->DriverBindingHandle, 923 Controller 924 ); 925 926 gBS->UninstallMultipleProtocolInterfaces ( 927 Controller, 928 &gEfiCallerIdGuid, 929 IdeBusDriverPrivateData, 930 NULL 931 ); 932 933 if (IdeBusDriverPrivateData != NULL) { 934 gBS->FreePool (IdeBusDriverPrivateData); 935 } 936 937 if (SupportedModes != NULL) { 938 gBS->FreePool (SupportedModes); 939 } 940 941 gBS->CloseProtocol ( 942 Controller, 943 &gEfiPciIoProtocolGuid, 944 This->DriverBindingHandle, 945 Controller 946 ); 947 948 gBS->CloseProtocol ( 949 Controller, 950 &gEfiDevicePathProtocolGuid, 951 This->DriverBindingHandle, 952 Controller 953 ); 954 955 return Status; 956 957 } 958 /** 959 Stop function of Driver Binding Protocol which is to stop the driver on Controller Handle and all 960 child handle attached to the controller handle if there are. 961 962 @param This Protocol instance pointer. 963 @param Controller Handle of device to stop driver on 964 @param NumberOfChildren Not used 965 @param ChildHandleBuffer Not used 966 967 @retval EFI_SUCCESS This driver is removed DeviceHandle 968 @retval other This driver was not removed from this device 969 970 **/ 971 EFI_STATUS 972 EFIAPI 973 IDEBusDriverBindingStop ( 974 IN EFI_DRIVER_BINDING_PROTOCOL *This, 975 IN EFI_HANDLE Controller, 976 IN UINTN NumberOfChildren, 977 IN EFI_HANDLE *ChildHandleBuffer 978 ) 979 { 980 EFI_STATUS Status; 981 EFI_PCI_IO_PROTOCOL *PciIo; 982 BOOLEAN AllChildrenStopped; 983 UINTN Index; 984 IDE_BUS_DRIVER_PRIVATE_DATA *IdeBusDriverPrivateData; 985 UINT64 Supports; 986 987 IdeBusDriverPrivateData = NULL; 988 989 if (NumberOfChildren == 0) { 990 991 Status = gBS->OpenProtocol ( 992 Controller, 993 &gEfiPciIoProtocolGuid, 994 (VOID **) &PciIo, 995 This->DriverBindingHandle, 996 Controller, 997 EFI_OPEN_PROTOCOL_GET_PROTOCOL 998 ); 999 if (!EFI_ERROR (Status)) { 1000 Status = PciIo->Attributes ( 1001 PciIo, 1002 EfiPciIoAttributeOperationSupported, 1003 0, 1004 &Supports 1005 ); 1006 if (!EFI_ERROR (Status)) { 1007 Supports &= (UINT64)(EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE); 1008 PciIo->Attributes ( 1009 PciIo, 1010 EfiPciIoAttributeOperationDisable, 1011 Supports, 1012 NULL 1013 ); 1014 } 1015 } 1016 1017 gBS->OpenProtocol ( 1018 Controller, 1019 &gEfiCallerIdGuid, 1020 (VOID **) &IdeBusDriverPrivateData, 1021 This->DriverBindingHandle, 1022 Controller, 1023 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1024 ); 1025 1026 gBS->UninstallMultipleProtocolInterfaces ( 1027 Controller, 1028 &gEfiCallerIdGuid, 1029 IdeBusDriverPrivateData, 1030 NULL 1031 ); 1032 1033 if (IdeBusDriverPrivateData != NULL) { 1034 gBS->FreePool (IdeBusDriverPrivateData); 1035 } 1036 // 1037 // Close the bus driver 1038 // 1039 gBS->CloseProtocol ( 1040 Controller, 1041 &gEfiIdeControllerInitProtocolGuid, 1042 This->DriverBindingHandle, 1043 Controller 1044 ); 1045 gBS->CloseProtocol ( 1046 Controller, 1047 &gEfiPciIoProtocolGuid, 1048 This->DriverBindingHandle, 1049 Controller 1050 ); 1051 gBS->CloseProtocol ( 1052 Controller, 1053 &gEfiDevicePathProtocolGuid, 1054 This->DriverBindingHandle, 1055 Controller 1056 ); 1057 1058 return EFI_SUCCESS; 1059 } 1060 1061 AllChildrenStopped = TRUE; 1062 1063 for (Index = 0; Index < NumberOfChildren; Index++) { 1064 1065 Status = DeRegisterIdeDevice (This, Controller, ChildHandleBuffer[Index]); 1066 1067 if (EFI_ERROR (Status)) { 1068 AllChildrenStopped = FALSE; 1069 } 1070 } 1071 1072 if (!AllChildrenStopped) { 1073 return EFI_DEVICE_ERROR; 1074 } 1075 1076 return EFI_SUCCESS; 1077 } 1078 1079 /** 1080 issue ATA or ATAPI command to reset a block IO device. 1081 @param This Block IO protocol instance pointer. 1082 @param ExtendedVerification If FALSE,for ATAPI device, driver will only invoke ATAPI reset method 1083 If TRUE, for ATAPI device, driver need invoke ATA reset method after 1084 invoke ATAPI reset method 1085 1086 @retval EFI_DEVICE_ERROR When the device is neighther ATA device or ATAPI device. 1087 @retval EFI_SUCCESS The device reset successfully 1088 1089 **/ 1090 EFI_STATUS 1091 EFIAPI 1092 IDEBlkIoReset ( 1093 IN EFI_BLOCK_IO_PROTOCOL *This, 1094 IN BOOLEAN ExtendedVerification 1095 ) 1096 { 1097 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1098 EFI_STATUS Status; 1099 EFI_TPL OldTpl; 1100 1101 OldTpl = gBS->RaiseTPL (TPL_CALLBACK); 1102 1103 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This); 1104 // 1105 // Requery IDE IO resources in case of the switch of native and legacy modes 1106 // 1107 ReassignIdeResources (IdeBlkIoDevice); 1108 1109 // 1110 // for ATA device, using ATA reset method 1111 // 1112 if (IdeBlkIoDevice->Type == IdeHardDisk || 1113 IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) { 1114 Status = AtaSoftReset (IdeBlkIoDevice); 1115 goto Done; 1116 } 1117 1118 if (IdeBlkIoDevice->Type == IdeUnknown) { 1119 Status = EFI_DEVICE_ERROR; 1120 goto Done; 1121 } 1122 1123 // 1124 // for ATAPI device, using ATAPI reset method 1125 // 1126 Status = AtapiSoftReset (IdeBlkIoDevice); 1127 if (ExtendedVerification) { 1128 Status = AtaSoftReset (IdeBlkIoDevice); 1129 } 1130 1131 Done: 1132 gBS->RestoreTPL (OldTpl); 1133 return Status; 1134 } 1135 1136 /** 1137 Read data from a block IO device 1138 1139 @param This Block IO protocol instance pointer. 1140 @param MediaId The media ID of the device 1141 @param Lba Starting LBA address to read data 1142 @param BufferSize The size of data to be read 1143 @param Buffer Caller supplied buffer to save data 1144 1145 @retval EFI_DEVICE_ERROR unknown device type 1146 @retval other read data status. 1147 1148 **/ 1149 EFI_STATUS 1150 EFIAPI 1151 IDEBlkIoReadBlocks ( 1152 IN EFI_BLOCK_IO_PROTOCOL *This, 1153 IN UINT32 MediaId, 1154 IN EFI_LBA Lba, 1155 IN UINTN BufferSize, 1156 OUT VOID *Buffer 1157 ) 1158 { 1159 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1160 EFI_STATUS Status; 1161 EFI_TPL OldTpl; 1162 1163 OldTpl = gBS->RaiseTPL (TPL_CALLBACK); 1164 1165 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This); 1166 1167 // 1168 // Requery IDE IO resources in case of the switch of native and legacy modes 1169 // 1170 ReassignIdeResources (IdeBlkIoDevice); 1171 1172 // 1173 // For ATA compatible device, use ATA read block's mechanism 1174 // 1175 if (IdeBlkIoDevice->Type == IdeHardDisk || 1176 IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) { 1177 Status = AtaBlkIoReadBlocks ( 1178 IdeBlkIoDevice, 1179 MediaId, 1180 Lba, 1181 BufferSize, 1182 Buffer 1183 ); 1184 goto Done; 1185 } 1186 1187 if (IdeBlkIoDevice->Type == IdeUnknown) { 1188 Status = EFI_DEVICE_ERROR; 1189 goto Done; 1190 } 1191 1192 // 1193 // for ATAPI device, using ATAPI read block's mechanism 1194 // 1195 Status = AtapiBlkIoReadBlocks ( 1196 IdeBlkIoDevice, 1197 MediaId, 1198 Lba, 1199 BufferSize, 1200 Buffer 1201 ); 1202 1203 Done: 1204 gBS->RestoreTPL (OldTpl); 1205 1206 return Status; 1207 } 1208 1209 /** 1210 Write data to block io device. 1211 1212 @param This Protocol instance pointer. 1213 @param MediaId The media ID of the device 1214 @param Lba Starting LBA address to write data 1215 @param BufferSize The size of data to be written 1216 @param Buffer Caller supplied buffer to save data 1217 1218 @retval EFI_DEVICE_ERROR unknown device type 1219 @retval other write data status 1220 1221 **/ 1222 EFI_STATUS 1223 EFIAPI 1224 IDEBlkIoWriteBlocks ( 1225 IN EFI_BLOCK_IO_PROTOCOL *This, 1226 IN UINT32 MediaId, 1227 IN EFI_LBA Lba, 1228 IN UINTN BufferSize, 1229 IN VOID *Buffer 1230 ) 1231 { 1232 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1233 EFI_STATUS Status; 1234 EFI_TPL OldTpl; 1235 1236 OldTpl = gBS->RaiseTPL (TPL_CALLBACK); 1237 1238 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This); 1239 // 1240 // Requery IDE IO resources in case of the switch of native and legacy modes 1241 // 1242 ReassignIdeResources (IdeBlkIoDevice); 1243 1244 // 1245 // for ATA device, using ATA write block's mechanism 1246 // 1247 if (IdeBlkIoDevice->Type == IdeHardDisk || 1248 IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) { 1249 1250 Status = AtaBlkIoWriteBlocks ( 1251 IdeBlkIoDevice, 1252 MediaId, 1253 Lba, 1254 BufferSize, 1255 Buffer 1256 ); 1257 goto Done; 1258 } 1259 1260 if (IdeBlkIoDevice->Type == IdeUnknown) { 1261 Status = EFI_DEVICE_ERROR; 1262 goto Done; 1263 } 1264 1265 // 1266 // for ATAPI device, using ATAPI write block's mechanism 1267 // 1268 Status = AtapiBlkIoWriteBlocks ( 1269 IdeBlkIoDevice, 1270 MediaId, 1271 Lba, 1272 BufferSize, 1273 Buffer 1274 ); 1275 1276 Done: 1277 gBS->RestoreTPL (OldTpl); 1278 return Status; 1279 } 1280 /** 1281 Flushes all modified data to a physical block devices 1282 1283 @param This Indicates a pointer to the calling context which to sepcify a 1284 sepcific block device 1285 1286 @retval EFI_SUCCESS Always return success. 1287 **/ 1288 EFI_STATUS 1289 EFIAPI 1290 IDEBlkIoFlushBlocks ( 1291 IN EFI_BLOCK_IO_PROTOCOL *This 1292 ) 1293 { 1294 // 1295 // return directly 1296 // 1297 return EFI_SUCCESS; 1298 } 1299 1300 /** 1301 This function is used by the IDE bus driver to get inquiry data. 1302 Data format of Identify data is defined by the Interface GUID. 1303 1304 @param This Pointer to the EFI_DISK_INFO_PROTOCOL instance. 1305 @param InquiryData Pointer to a buffer for the inquiry data. 1306 @param InquiryDataSize Pointer to the value for the inquiry data size. 1307 1308 @retval EFI_SUCCESS The command was accepted without any errors. 1309 @retval EFI_NOT_FOUND Device does not support this data class 1310 @retval EFI_DEVICE_ERROR Error reading InquiryData from device 1311 @retval EFI_BUFFER_TOO_SMALL IntquiryDataSize not big enough 1312 1313 **/ 1314 EFI_STATUS 1315 EFIAPI 1316 IDEDiskInfoInquiry ( 1317 IN EFI_DISK_INFO_PROTOCOL *This, 1318 IN OUT VOID *InquiryData, 1319 IN OUT UINT32 *InquiryDataSize 1320 ) 1321 { 1322 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1323 1324 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This); 1325 1326 if (*InquiryDataSize < sizeof (ATAPI_INQUIRY_DATA)) { 1327 *InquiryDataSize = sizeof (ATAPI_INQUIRY_DATA); 1328 return EFI_BUFFER_TOO_SMALL; 1329 } 1330 1331 if (IdeBlkIoDevice->InquiryData == NULL) { 1332 return EFI_NOT_FOUND; 1333 } 1334 1335 gBS->CopyMem (InquiryData, IdeBlkIoDevice->InquiryData, sizeof (ATAPI_INQUIRY_DATA)); 1336 *InquiryDataSize = sizeof (ATAPI_INQUIRY_DATA); 1337 1338 return EFI_SUCCESS; 1339 } 1340 1341 /** 1342 This function is used by the IDE bus driver to get identify data. 1343 Data format of Identify data is defined by the Interface GUID. 1344 1345 @param This Pointer to the EFI_DISK_INFO_PROTOCOL instance. 1346 @param IdentifyData Pointer to a buffer for the identify data. 1347 @param IdentifyDataSize Pointer to the value for the identify data size. 1348 1349 @retval EFI_SUCCESS The command was accepted without any errors. 1350 @retval EFI_NOT_FOUND Device does not support this data class 1351 @retval EFI_DEVICE_ERROR Error reading IdentifyData from device 1352 @retval EFI_BUFFER_TOO_SMALL IdentifyDataSize not big enough 1353 1354 **/ 1355 EFI_STATUS 1356 EFIAPI 1357 IDEDiskInfoIdentify ( 1358 IN EFI_DISK_INFO_PROTOCOL *This, 1359 IN OUT VOID *IdentifyData, 1360 IN OUT UINT32 *IdentifyDataSize 1361 ) 1362 { 1363 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1364 1365 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This); 1366 1367 if (*IdentifyDataSize < sizeof (EFI_IDENTIFY_DATA)) { 1368 *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA); 1369 return EFI_BUFFER_TOO_SMALL; 1370 } 1371 1372 if (IdeBlkIoDevice->IdData == NULL) { 1373 return EFI_NOT_FOUND; 1374 } 1375 1376 gBS->CopyMem (IdentifyData, IdeBlkIoDevice->IdData, sizeof (EFI_IDENTIFY_DATA)); 1377 *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA); 1378 1379 return EFI_SUCCESS; 1380 } 1381 1382 /** 1383 This function is used by the IDE bus driver to get sense data. 1384 Data format of Sense data is defined by the Interface GUID. 1385 1386 @param This Pointer to the EFI_DISK_INFO_PROTOCOL instance. 1387 @param SenseData Pointer to the SenseData. 1388 @param SenseDataSize Size of SenseData in bytes. 1389 @param SenseDataNumber Pointer to the value for the identify data size. 1390 1391 @retval EFI_SUCCESS The command was accepted without any errors. 1392 @retval EFI_NOT_FOUND Device does not support this data class 1393 @retval EFI_DEVICE_ERROR Error reading InquiryData from device 1394 @retval EFI_BUFFER_TOO_SMALL SenseDataSize not big enough 1395 1396 **/ 1397 EFI_STATUS 1398 EFIAPI 1399 IDEDiskInfoSenseData ( 1400 IN EFI_DISK_INFO_PROTOCOL *This, 1401 IN OUT VOID *SenseData, 1402 IN OUT UINT32 *SenseDataSize, 1403 OUT UINT8 *SenseDataNumber 1404 ) 1405 { 1406 return EFI_NOT_FOUND; 1407 } 1408 1409 /** 1410 This function is used by the IDE bus driver to get controller information. 1411 1412 @param This Pointer to the EFI_DISK_INFO_PROTOCOL instance. 1413 @param IdeChannel Pointer to the Ide Channel number. Primary or secondary. 1414 @param IdeDevice Pointer to the Ide Device number. Master or slave. 1415 1416 @retval EFI_SUCCESS IdeChannel and IdeDevice are valid 1417 @retval EFI_UNSUPPORTED This is not an IDE device 1418 1419 **/ 1420 EFI_STATUS 1421 EFIAPI 1422 IDEDiskInfoWhichIde ( 1423 IN EFI_DISK_INFO_PROTOCOL *This, 1424 OUT UINT32 *IdeChannel, 1425 OUT UINT32 *IdeDevice 1426 ) 1427 { 1428 IDE_BLK_IO_DEV *IdeBlkIoDevice; 1429 1430 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This); 1431 *IdeChannel = IdeBlkIoDevice->Channel; 1432 *IdeDevice = IdeBlkIoDevice->Device; 1433 1434 return EFI_SUCCESS; 1435 } 1436 1437 /** 1438 The is an event(generally the event is exitBootService event) call back function. 1439 Clear pending IDE interrupt before OS loader/kernel take control of the IDE device. 1440 1441 @param Event Pointer to this event 1442 @param Context Event handler private data 1443 1444 **/ 1445 VOID 1446 EFIAPI 1447 ClearInterrupt ( 1448 IN EFI_EVENT Event, 1449 IN VOID *Context 1450 ) 1451 { 1452 EFI_STATUS Status; 1453 UINT64 IoPortForBmis; 1454 UINT8 RegisterValue; 1455 IDE_BLK_IO_DEV *IdeDev; 1456 1457 // 1458 // Get our context 1459 // 1460 IdeDev = (IDE_BLK_IO_DEV *) Context; 1461 1462 // 1463 // Obtain IDE IO port registers' base addresses 1464 // 1465 Status = ReassignIdeResources (IdeDev); 1466 if (EFI_ERROR (Status)) { 1467 return; 1468 } 1469 1470 // 1471 // Check whether interrupt is pending 1472 // 1473 1474 // 1475 // Reset IDE device to force it de-assert interrupt pin 1476 // Note: this will reset all devices on this IDE channel 1477 // 1478 Status = AtaSoftReset (IdeDev); 1479 if (EFI_ERROR (Status)) { 1480 return; 1481 } 1482 1483 // 1484 // Get base address of IDE Bus Master Status Regsiter 1485 // 1486 if (IdePrimary == IdeDev->Channel) { 1487 IoPortForBmis = IdeDev->IoPort->BusMasterBaseAddr + BMISP_OFFSET; 1488 } else { 1489 if (IdeSecondary == IdeDev->Channel) { 1490 IoPortForBmis = IdeDev->IoPort->BusMasterBaseAddr + BMISS_OFFSET; 1491 } else { 1492 return; 1493 } 1494 } 1495 // 1496 // Read BMIS register and clear ERROR and INTR bit 1497 // 1498 IdeDev->PciIo->Io.Read ( 1499 IdeDev->PciIo, 1500 EfiPciIoWidthUint8, 1501 EFI_PCI_IO_PASS_THROUGH_BAR, 1502 IoPortForBmis, 1503 1, 1504 &RegisterValue 1505 ); 1506 1507 RegisterValue |= (BMIS_INTERRUPT | BMIS_ERROR); 1508 1509 IdeDev->PciIo->Io.Write ( 1510 IdeDev->PciIo, 1511 EfiPciIoWidthUint8, 1512 EFI_PCI_IO_PASS_THROUGH_BAR, 1513 IoPortForBmis, 1514 1, 1515 &RegisterValue 1516 ); 1517 1518 // 1519 // Select the other device on this channel to ensure this device to release the interrupt pin 1520 // 1521 if (IdeDev->Device == 0) { 1522 RegisterValue = (1 << 4) | 0xe0; 1523 } else { 1524 RegisterValue = (0 << 4) | 0xe0; 1525 } 1526 IDEWritePortB ( 1527 IdeDev->PciIo, 1528 IdeDev->IoPort->Head, 1529 RegisterValue 1530 ); 1531 1532 } 1533 1534 /** 1535 The user Entry Point for module IdeBus. The user code starts with this function. 1536 1537 @param[in] ImageHandle The firmware allocated handle for the EFI image. 1538 @param[in] SystemTable A pointer to the EFI System Table. 1539 1540 @retval EFI_SUCCESS The entry point is executed successfully. 1541 @retval other Some error occurs when executing this entry point. 1542 1543 **/ 1544 EFI_STATUS 1545 EFIAPI 1546 InitializeIdeBus( 1547 IN EFI_HANDLE ImageHandle, 1548 IN EFI_SYSTEM_TABLE *SystemTable 1549 ) 1550 { 1551 EFI_STATUS Status; 1552 1553 // 1554 // Install driver model protocol(s). 1555 // 1556 Status = EfiLibInstallAllDriverProtocols2 ( 1557 ImageHandle, 1558 SystemTable, 1559 &gIDEBusDriverBinding, 1560 ImageHandle, 1561 &gIDEBusComponentName, 1562 &gIDEBusComponentName2, 1563 NULL, 1564 NULL, 1565 &gIDEBusDriverDiagnostics, 1566 &gIDEBusDriverDiagnostics2 1567 ); 1568 ASSERT_EFI_ERROR (Status); 1569 1570 return Status; 1571 } 1572
