1 /** @file 2 PEIM to produce gEfiPeiVirtualBlockIoPpiGuid & gEfiPeiVirtualBlockIo2PpiGuid PPI for 3 ATA controllers in the platform. 4 5 This PPI can be consumed by PEIM which produce gEfiPeiDeviceRecoveryModulePpiGuid 6 for Atapi CD ROM device. 7 8 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR> 9 10 This program and the accompanying materials 11 are licensed and made available under the terms and conditions 12 of the BSD License which accompanies this distribution. The 13 full text of the license may be found at 14 http://opensource.org/licenses/bsd-license.php 15 16 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 17 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 18 19 **/ 20 21 #include "AtapiPeim.h" 22 23 /** 24 Initializes the Atapi Block Io PPI. 25 26 @param[in] FileHandle Handle of the file being invoked. 27 @param[in] PeiServices Describes the list of possible PEI Services. 28 29 @retval EFI_SUCCESS Operation performed successfully. 30 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate. 31 32 **/ 33 EFI_STATUS 34 EFIAPI 35 AtapiPeimEntry ( 36 IN EFI_PEI_FILE_HANDLE FileHandle, 37 IN CONST EFI_PEI_SERVICES **PeiServices 38 ) 39 { 40 PEI_ATA_CONTROLLER_PPI *AtaControllerPpi; 41 EFI_STATUS Status; 42 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 43 44 Status = PeiServicesRegisterForShadow (FileHandle); 45 if (!EFI_ERROR (Status)) { 46 return Status; 47 } 48 49 Status = PeiServicesLocatePpi ( 50 &gPeiAtaControllerPpiGuid, 51 0, 52 NULL, 53 (VOID **) &AtaControllerPpi 54 ); 55 ASSERT_EFI_ERROR (Status); 56 57 AtapiBlkIoDev = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*AtapiBlkIoDev))); 58 if (AtapiBlkIoDev == NULL) { 59 return EFI_OUT_OF_RESOURCES; 60 } 61 62 AtapiBlkIoDev->Signature = ATAPI_BLK_IO_DEV_SIGNATURE; 63 AtapiBlkIoDev->AtaControllerPpi = AtaControllerPpi; 64 65 // 66 // atapi device enumeration and build private data 67 // 68 AtapiEnumerateDevices (AtapiBlkIoDev); 69 70 AtapiBlkIoDev->AtapiBlkIo.GetNumberOfBlockDevices = AtapiGetNumberOfBlockDevices; 71 AtapiBlkIoDev->AtapiBlkIo.GetBlockDeviceMediaInfo = AtapiGetBlockDeviceMediaInfo; 72 AtapiBlkIoDev->AtapiBlkIo.ReadBlocks = AtapiReadBlocks; 73 AtapiBlkIoDev->AtapiBlkIo2.Revision = EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION; 74 AtapiBlkIoDev->AtapiBlkIo2.GetNumberOfBlockDevices = AtapiGetNumberOfBlockDevices2; 75 AtapiBlkIoDev->AtapiBlkIo2.GetBlockDeviceMediaInfo = AtapiGetBlockDeviceMediaInfo2; 76 AtapiBlkIoDev->AtapiBlkIo2.ReadBlocks = AtapiReadBlocks2; 77 78 AtapiBlkIoDev->PpiDescriptor.Flags = EFI_PEI_PPI_DESCRIPTOR_PPI; 79 AtapiBlkIoDev->PpiDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid; 80 AtapiBlkIoDev->PpiDescriptor.Ppi = &AtapiBlkIoDev->AtapiBlkIo; 81 82 AtapiBlkIoDev->PpiDescriptor2.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); 83 AtapiBlkIoDev->PpiDescriptor2.Guid = &gEfiPeiVirtualBlockIo2PpiGuid; 84 AtapiBlkIoDev->PpiDescriptor2.Ppi = &AtapiBlkIoDev->AtapiBlkIo2; 85 86 DEBUG ((EFI_D_INFO, "Atatpi Device Count is %d\n", AtapiBlkIoDev->DeviceCount)); 87 if (AtapiBlkIoDev->DeviceCount != 0) { 88 Status = PeiServicesInstallPpi (&AtapiBlkIoDev->PpiDescriptor); 89 if (EFI_ERROR (Status)) { 90 return EFI_OUT_OF_RESOURCES; 91 } 92 } 93 94 return EFI_SUCCESS; 95 } 96 97 /** 98 Gets the count of block I/O devices that one specific block driver detects. 99 100 This function is used for getting the count of block I/O devices that one 101 specific block driver detects. To the PEI ATAPI driver, it returns the number 102 of all the detected ATAPI devices it detects during the enumeration process. 103 To the PEI legacy floppy driver, it returns the number of all the legacy 104 devices it finds during its enumeration process. If no device is detected, 105 then the function will return zero. 106 107 @param[in] PeiServices General-purpose services that are available 108 to every PEIM. 109 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI 110 instance. 111 @param[out] NumberBlockDevices The number of block I/O devices discovered. 112 113 @retval EFI_SUCCESS Operation performed successfully. 114 115 **/ 116 EFI_STATUS 117 EFIAPI 118 AtapiGetNumberOfBlockDevices ( 119 IN EFI_PEI_SERVICES **PeiServices, 120 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 121 OUT UINTN *NumberBlockDevices 122 ) 123 { 124 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 125 126 AtapiBlkIoDev = NULL; 127 128 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This); 129 130 *NumberBlockDevices = AtapiBlkIoDev->DeviceCount; 131 132 return EFI_SUCCESS; 133 } 134 135 /** 136 Gets a block device's media information. 137 138 This function will provide the caller with the specified block device's media 139 information. If the media changes, calling this function will update the media 140 information accordingly. 141 142 @param[in] PeiServices General-purpose services that are available to every 143 PEIM 144 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance. 145 @param[in] DeviceIndex Specifies the block device to which the function wants 146 to talk. Because the driver that implements Block I/O 147 PPIs will manage multiple block devices, the PPIs that 148 want to talk to a single device must specify the 149 device index that was assigned during the enumeration 150 process. This index is a number from one to 151 NumberBlockDevices. 152 @param[out] MediaInfo The media information of the specified block media. 153 The caller is responsible for the ownership of this 154 data structure. 155 156 @retval EFI_SUCCESS Media information about the specified block device 157 was obtained successfully. 158 @retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware 159 error. 160 @retval Others Other failure occurs. 161 162 **/ 163 EFI_STATUS 164 EFIAPI 165 AtapiGetBlockDeviceMediaInfo ( 166 IN EFI_PEI_SERVICES **PeiServices, 167 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 168 IN UINTN DeviceIndex, 169 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo 170 ) 171 { 172 UINTN DeviceCount; 173 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 174 EFI_STATUS Status; 175 UINTN Index; 176 177 AtapiBlkIoDev = NULL; 178 179 if (This == NULL || MediaInfo == NULL) { 180 return EFI_INVALID_PARAMETER; 181 } 182 183 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This); 184 185 DeviceCount = AtapiBlkIoDev->DeviceCount; 186 187 // 188 // DeviceIndex is a value from 1 to NumberBlockDevices. 189 // 190 if ((DeviceIndex < 1) || (DeviceIndex > DeviceCount) || (DeviceIndex > MAX_IDE_DEVICES)) { 191 return EFI_INVALID_PARAMETER; 192 } 193 194 Index = DeviceIndex - 1; 195 196 // 197 // probe media and retrieve latest media information 198 // 199 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition)); 200 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType)); 201 DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent)); 202 DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize)); 203 DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock)); 204 205 Status = DetectMedia ( 206 AtapiBlkIoDev, 207 AtapiBlkIoDev->DeviceInfo[Index].DevicePosition, 208 &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo, 209 &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo2 210 ); 211 if (Status != EFI_SUCCESS) { 212 return EFI_DEVICE_ERROR; 213 } 214 215 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition)); 216 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType)); 217 DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent)); 218 DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize)); 219 DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock)); 220 221 // 222 // Get media info from AtapiBlkIoDev 223 // 224 CopyMem (MediaInfo, &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo, sizeof(EFI_PEI_BLOCK_IO_MEDIA)); 225 226 return EFI_SUCCESS; 227 } 228 229 /** 230 Reads the requested number of blocks from the specified block device. 231 232 The function reads the requested number of blocks from the device. All the 233 blocks are read, or an error is returned. If there is no media in the device, 234 the function returns EFI_NO_MEDIA. 235 236 @param[in] PeiServices General-purpose services that are available to 237 every PEIM. 238 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance. 239 @param[in] DeviceIndex Specifies the block device to which the function wants 240 to talk. Because the driver that implements Block I/O 241 PPIs will manage multiple block devices, the PPIs that 242 want to talk to a single device must specify the device 243 index that was assigned during the enumeration process. 244 This index is a number from one to NumberBlockDevices. 245 @param[in] StartLBA The starting logical block address (LBA) to read from 246 on the device 247 @param[in] BufferSize The size of the Buffer in bytes. This number must be 248 a multiple of the intrinsic block size of the device. 249 @param[out] Buffer A pointer to the destination buffer for the data. 250 The caller is responsible for the ownership of the 251 buffer. 252 253 @retval EFI_SUCCESS The data was read correctly from the device. 254 @retval EFI_DEVICE_ERROR The device reported an error while attempting 255 to perform the read operation. 256 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not 257 valid, or the buffer is not properly aligned. 258 @retval EFI_NO_MEDIA There is no media in the device. 259 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of 260 the intrinsic block size of the device. 261 262 **/ 263 EFI_STATUS 264 EFIAPI 265 AtapiReadBlocks ( 266 IN EFI_PEI_SERVICES **PeiServices, 267 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 268 IN UINTN DeviceIndex, 269 IN EFI_PEI_LBA StartLBA, 270 IN UINTN BufferSize, 271 OUT VOID *Buffer 272 ) 273 { 274 275 EFI_PEI_BLOCK_IO_MEDIA MediaInfo; 276 EFI_STATUS Status; 277 UINTN NumberOfBlocks; 278 UINTN BlockSize; 279 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 280 281 AtapiBlkIoDev = NULL; 282 283 if (This == NULL) { 284 return EFI_INVALID_PARAMETER; 285 } 286 287 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This); 288 289 if (Buffer == NULL) { 290 return EFI_INVALID_PARAMETER; 291 } 292 293 if (BufferSize == 0) { 294 return EFI_SUCCESS; 295 } 296 297 Status = AtapiGetBlockDeviceMediaInfo ( 298 PeiServices, 299 This, 300 DeviceIndex, 301 &MediaInfo 302 ); 303 if (Status != EFI_SUCCESS) { 304 return EFI_DEVICE_ERROR; 305 } 306 307 if (!MediaInfo.MediaPresent) { 308 return EFI_NO_MEDIA; 309 } 310 311 BlockSize = MediaInfo.BlockSize; 312 313 if (BufferSize % BlockSize != 0) { 314 return EFI_BAD_BUFFER_SIZE; 315 } 316 317 NumberOfBlocks = BufferSize / BlockSize; 318 319 if ((StartLBA + NumberOfBlocks - 1) > AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].MediaInfo2.LastBlock) { 320 return EFI_INVALID_PARAMETER; 321 } 322 323 Status = ReadSectors ( 324 AtapiBlkIoDev, 325 AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].DevicePosition, 326 Buffer, 327 StartLBA, 328 NumberOfBlocks, 329 BlockSize 330 ); 331 if (EFI_ERROR (Status)) { 332 return EFI_DEVICE_ERROR; 333 } 334 335 return EFI_SUCCESS; 336 } 337 338 /** 339 Gets the count of block I/O devices that one specific block driver detects. 340 341 This function is used for getting the count of block I/O devices that one 342 specific block driver detects. To the PEI ATAPI driver, it returns the number 343 of all the detected ATAPI devices it detects during the enumeration process. 344 To the PEI legacy floppy driver, it returns the number of all the legacy 345 devices it finds during its enumeration process. If no device is detected, 346 then the function will return zero. 347 348 @param[in] PeiServices General-purpose services that are available 349 to every PEIM. 350 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI 351 instance. 352 @param[out] NumberBlockDevices The number of block I/O devices discovered. 353 354 @retval EFI_SUCCESS Operation performed successfully. 355 356 **/ 357 EFI_STATUS 358 EFIAPI 359 AtapiGetNumberOfBlockDevices2 ( 360 IN EFI_PEI_SERVICES **PeiServices, 361 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 362 OUT UINTN *NumberBlockDevices 363 ) 364 { 365 EFI_STATUS Status; 366 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 367 368 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This); 369 370 Status = AtapiGetNumberOfBlockDevices ( 371 PeiServices, 372 &AtapiBlkIoDev->AtapiBlkIo, 373 NumberBlockDevices 374 ); 375 376 return Status; 377 } 378 379 /** 380 Gets a block device's media information. 381 382 This function will provide the caller with the specified block device's media 383 information. If the media changes, calling this function will update the media 384 information accordingly. 385 386 @param[in] PeiServices General-purpose services that are available to every 387 PEIM 388 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance. 389 @param[in] DeviceIndex Specifies the block device to which the function wants 390 to talk. Because the driver that implements Block I/O 391 PPIs will manage multiple block devices, the PPIs that 392 want to talk to a single device must specify the 393 device index that was assigned during the enumeration 394 process. This index is a number from one to 395 NumberBlockDevices. 396 @param[out] MediaInfo The media information of the specified block media. 397 The caller is responsible for the ownership of this 398 data structure. 399 400 @retval EFI_SUCCESS Media information about the specified block device 401 was obtained successfully. 402 @retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware 403 error. 404 @retval Others Other failure occurs. 405 406 **/ 407 EFI_STATUS 408 EFIAPI 409 AtapiGetBlockDeviceMediaInfo2 ( 410 IN EFI_PEI_SERVICES **PeiServices, 411 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 412 IN UINTN DeviceIndex, 413 OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo 414 ) 415 { 416 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 417 EFI_STATUS Status; 418 EFI_PEI_BLOCK_IO_MEDIA Media; 419 420 AtapiBlkIoDev = NULL; 421 422 if (This == NULL || MediaInfo == NULL) { 423 return EFI_INVALID_PARAMETER; 424 } 425 426 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This); 427 428 Status = AtapiGetBlockDeviceMediaInfo ( 429 PeiServices, 430 &AtapiBlkIoDev->AtapiBlkIo, 431 DeviceIndex, 432 &Media 433 ); 434 if (EFI_ERROR (Status)) { 435 return Status; 436 } 437 // 438 // Get media info from AtapiBlkIoDev 439 // 440 CopyMem (MediaInfo, &AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].MediaInfo2, sizeof(EFI_PEI_BLOCK_IO2_MEDIA)); 441 442 return EFI_SUCCESS; 443 } 444 445 /** 446 Reads the requested number of blocks from the specified block device. 447 448 The function reads the requested number of blocks from the device. All the 449 blocks are read, or an error is returned. If there is no media in the device, 450 the function returns EFI_NO_MEDIA. 451 452 @param[in] PeiServices General-purpose services that are available to 453 every PEIM. 454 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance. 455 @param[in] DeviceIndex Specifies the block device to which the function wants 456 to talk. Because the driver that implements Block I/O 457 PPIs will manage multiple block devices, the PPIs that 458 want to talk to a single device must specify the device 459 index that was assigned during the enumeration process. 460 This index is a number from one to NumberBlockDevices. 461 @param[in] StartLBA The starting logical block address (LBA) to read from 462 on the device 463 @param[in] BufferSize The size of the Buffer in bytes. This number must be 464 a multiple of the intrinsic block size of the device. 465 @param[out] Buffer A pointer to the destination buffer for the data. 466 The caller is responsible for the ownership of the 467 buffer. 468 469 @retval EFI_SUCCESS The data was read correctly from the device. 470 @retval EFI_DEVICE_ERROR The device reported an error while attempting 471 to perform the read operation. 472 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not 473 valid, or the buffer is not properly aligned. 474 @retval EFI_NO_MEDIA There is no media in the device. 475 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of 476 the intrinsic block size of the device. 477 478 **/ 479 EFI_STATUS 480 EFIAPI 481 AtapiReadBlocks2 ( 482 IN EFI_PEI_SERVICES **PeiServices, 483 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 484 IN UINTN DeviceIndex, 485 IN EFI_PEI_LBA StartLBA, 486 IN UINTN BufferSize, 487 OUT VOID *Buffer 488 ) 489 { 490 EFI_STATUS Status; 491 ATAPI_BLK_IO_DEV *AtapiBlkIoDev; 492 493 AtapiBlkIoDev = NULL; 494 495 if (This == NULL) { 496 return EFI_INVALID_PARAMETER; 497 } 498 499 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This); 500 501 Status = AtapiReadBlocks ( 502 PeiServices, 503 &AtapiBlkIoDev->AtapiBlkIo, 504 DeviceIndex, 505 StartLBA, 506 BufferSize, 507 Buffer 508 ); 509 510 return Status; 511 } 512 513 514 /** 515 Enumerate Atapi devices. 516 517 This function is used to enumerate Atatpi device in Ide channel. 518 519 @param[in] AtapiBlkIoDev A pointer to atapi block IO device 520 521 **/ 522 VOID 523 AtapiEnumerateDevices ( 524 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev 525 ) 526 { 527 UINT8 Index1; 528 UINT8 Index2; 529 UINTN DevicePosition; 530 EFI_PEI_BLOCK_IO_MEDIA MediaInfo; 531 EFI_PEI_BLOCK_IO2_MEDIA MediaInfo2; 532 EFI_STATUS Status; 533 UINTN DeviceCount; 534 UINT16 CommandBlockBaseAddr; 535 UINT16 ControlBlockBaseAddr; 536 UINT32 IdeEnabledNumber; 537 IDE_REGS_BASE_ADDR IdeRegsBaseAddr[MAX_IDE_CHANNELS]; 538 539 DeviceCount = 0; 540 DevicePosition = 0; 541 542 // 543 // Scan IDE bus for ATAPI devices 544 // 545 546 // 547 // Enable Sata and IDE controller. 548 // 549 AtapiBlkIoDev->AtaControllerPpi->EnableAtaChannel ( 550 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer(), 551 AtapiBlkIoDev->AtaControllerPpi, 552 PEI_ICH_IDE_PRIMARY | PEI_ICH_IDE_SECONDARY 553 ); 554 555 // 556 // Allow SATA Devices to spin-up. This is needed if 557 // SEC and PEI phase is too short, for example Release Build. 558 // 559 DEBUG ((EFI_D_INFO, "Delay for %d seconds for SATA devices to spin-up\n", PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath))); 560 MicroSecondDelay (PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath) * 1000 * 1000); // 561 562 // 563 // Get four channels (primary or secondary Pata, Sata Channel) Command and Control Regs Base address. 564 // 565 IdeEnabledNumber = AtapiBlkIoDev->AtaControllerPpi->GetIdeRegsBaseAddr ( 566 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer(), 567 AtapiBlkIoDev->AtaControllerPpi, 568 IdeRegsBaseAddr 569 ); 570 571 // 572 // Using Command and Control Regs Base Address to fill other registers. 573 // 574 for (Index1 = 0; Index1 < IdeEnabledNumber; Index1 ++) { 575 CommandBlockBaseAddr = IdeRegsBaseAddr[Index1].CommandBlockBaseAddr; 576 AtapiBlkIoDev->IdeIoPortReg[Index1].Data = CommandBlockBaseAddr; 577 AtapiBlkIoDev->IdeIoPortReg[Index1].Reg1.Feature = (UINT16) (CommandBlockBaseAddr + 0x1); 578 AtapiBlkIoDev->IdeIoPortReg[Index1].SectorCount = (UINT16) (CommandBlockBaseAddr + 0x2); 579 AtapiBlkIoDev->IdeIoPortReg[Index1].SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x3); 580 AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x4); 581 AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x5); 582 AtapiBlkIoDev->IdeIoPortReg[Index1].Head = (UINT16) (CommandBlockBaseAddr + 0x6); 583 AtapiBlkIoDev->IdeIoPortReg[Index1].Reg.Command = (UINT16) (CommandBlockBaseAddr + 0x7); 584 585 ControlBlockBaseAddr = IdeRegsBaseAddr[Index1].ControlBlockBaseAddr; 586 AtapiBlkIoDev->IdeIoPortReg[Index1].Alt.DeviceControl = ControlBlockBaseAddr; 587 AtapiBlkIoDev->IdeIoPortReg[Index1].DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x1); 588 589 // 590 // Scan IDE bus for ATAPI devices IDE or Sata device 591 // 592 for (Index2 = IdeMaster; Index2 < IdeMaxDevice; Index2++) { 593 // 594 // Pata & Sata, Primary & Secondary channel, Master & Slave device 595 // 596 DevicePosition = (UINTN) (Index1 * 2 + Index2); 597 598 if (DiscoverAtapiDevice (AtapiBlkIoDev, DevicePosition, &MediaInfo, &MediaInfo2)) { 599 // 600 // ATAPI Device at DevicePosition is found. 601 // 602 AtapiBlkIoDev->DeviceInfo[DeviceCount].DevicePosition = DevicePosition; 603 // 604 // Retrieve Media Info 605 // 606 Status = DetectMedia (AtapiBlkIoDev, DevicePosition, &MediaInfo, &MediaInfo2); 607 CopyMem (&(AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo), &MediaInfo, sizeof (MediaInfo)); 608 CopyMem (&(AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2), &MediaInfo2, sizeof (MediaInfo2)); 609 610 DEBUG ((EFI_D_INFO, "Atatpi Device Position is %d\n", DevicePosition)); 611 DEBUG ((EFI_D_INFO, "Atatpi DeviceType is %d\n", MediaInfo.DeviceType)); 612 DEBUG ((EFI_D_INFO, "Atatpi MediaPresent is %d\n", MediaInfo.MediaPresent)); 613 DEBUG ((EFI_D_INFO, "Atatpi BlockSize is 0x%x\n", MediaInfo.BlockSize)); 614 615 if (EFI_ERROR (Status)) { 616 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.MediaPresent = FALSE; 617 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.LastBlock = 0; 618 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2.MediaPresent = FALSE; 619 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2.LastBlock = 0; 620 } 621 DeviceCount += 1; 622 } 623 } 624 } 625 626 AtapiBlkIoDev->DeviceCount = DeviceCount; 627 } 628 629 /** 630 Detect Atapi devices. 631 632 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 633 @param[in] DevicePosition An integer to signify device position. 634 @param[out] MediaInfo The media information of the specified block media. 635 @param[out] MediaInfo2 The media information 2 of the specified block media. 636 637 @retval TRUE Atapi device exists in specified position. 638 @retval FALSE Atapi device does not exist in specified position. 639 640 **/ 641 BOOLEAN 642 DiscoverAtapiDevice ( 643 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 644 IN UINTN DevicePosition, 645 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo, 646 OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2 647 ) 648 { 649 EFI_STATUS Status; 650 651 if (!DetectIDEController (AtapiBlkIoDev, DevicePosition)) { 652 return FALSE; 653 } 654 // 655 // test if it is an ATAPI device (only supported device) 656 // 657 if (ATAPIIdentify (AtapiBlkIoDev, DevicePosition) == EFI_SUCCESS) { 658 659 Status = Inquiry (AtapiBlkIoDev, DevicePosition, MediaInfo, MediaInfo2); 660 if (!EFI_ERROR (Status)) { 661 return TRUE; 662 } 663 } 664 665 return FALSE; 666 } 667 668 /** 669 Check power mode of Atapi devices. 670 671 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 672 @param[in] DevicePosition An integer to signify device position. 673 @param[in] AtaCommand The Ata Command passed in. 674 675 @retval EFI_SUCCESS The Atapi device support power mode. 676 @retval EFI_NOT_FOUND The Atapi device not found. 677 @retval EFI_TIMEOUT Atapi command transaction is time out. 678 @retval EFI_ABORTED Atapi command abort. 679 680 **/ 681 EFI_STATUS 682 CheckPowerMode ( 683 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 684 IN UINTN DevicePosition, 685 IN UINT8 AtaCommand 686 ) 687 { 688 UINT8 Channel; 689 UINT8 Device; 690 UINT16 StatusRegister; 691 UINT16 HeadRegister; 692 UINT16 CommandRegister; 693 UINT16 ErrorRegister; 694 UINT16 SectorCountRegister; 695 EFI_STATUS Status; 696 UINT8 StatusValue; 697 UINT8 ErrorValue; 698 UINT8 SectorCountValue; 699 700 Channel = (UINT8) (DevicePosition / 2); 701 Device = (UINT8) (DevicePosition % 2); 702 703 ASSERT (Channel < MAX_IDE_CHANNELS); 704 705 StatusRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status; 706 HeadRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Head; 707 CommandRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command; 708 ErrorRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Error; 709 SectorCountRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount; 710 711 // 712 // select device 713 // 714 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0)); 715 716 // 717 // refresh the SectorCount register 718 // 719 SectorCountValue = 0x55; 720 IoWrite8 (SectorCountRegister, SectorCountValue); 721 722 // 723 // select device 724 // 725 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0)); 726 727 Status = DRDYReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 100); 728 729 // 730 // select device 731 // 732 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0)); 733 // 734 // send 'check power' commandd via Command Register 735 // 736 IoWrite8 (CommandRegister, AtaCommand); 737 738 Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 3000); 739 if (EFI_ERROR (Status)) { 740 return EFI_TIMEOUT; 741 } 742 743 StatusValue = IoRead8 (StatusRegister); 744 745 // 746 // command returned status is DRDY, indicating device supports the command, 747 // so device is present. 748 // 749 if ((StatusValue & ATA_STSREG_DRDY) == ATA_STSREG_DRDY) { 750 return EFI_SUCCESS; 751 } 752 753 SectorCountValue = IoRead8 (SectorCountRegister); 754 755 // 756 // command returned status is ERR & ABRT_ERR, indicating device does not support 757 // the command, so device is present. 758 // 759 if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) { 760 ErrorValue = IoRead8 (ErrorRegister); 761 if ((ErrorValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 762 return EFI_ABORTED; 763 } else { 764 // 765 // According to spec, no other error code is valid 766 // 767 return EFI_NOT_FOUND; 768 } 769 } 770 771 if ((SectorCountValue == 0x00) || (SectorCountValue == 0x80) || (SectorCountValue == 0xff)) { 772 // 773 // Write SectorCount 0x55 but return valid state value. Maybe no device 774 // exists or some slow kind of ATAPI device exists. 775 // 776 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0)); 777 778 // 779 // write 0x55 and 0xaa to SectorCounter register, 780 // if the data could be written into the register, 781 // indicating the device is present, otherwise the device is not present. 782 // 783 SectorCountValue = 0x55; 784 IoWrite8 (SectorCountRegister, SectorCountValue); 785 MicroSecondDelay (10000); 786 787 SectorCountValue = IoRead8 (SectorCountRegister); 788 if (SectorCountValue != 0x55) { 789 return EFI_NOT_FOUND; 790 } 791 // 792 // Send a "ATAPI TEST UNIT READY" command ... slow but accurate 793 // 794 Status = TestUnitReady (AtapiBlkIoDev, DevicePosition); 795 return Status; 796 } 797 798 return EFI_NOT_FOUND; 799 } 800 801 /** 802 Detect if an IDE controller exists in specified position. 803 804 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 805 @param[in] DevicePosition An integer to signify device position. 806 807 @retval TRUE The Atapi device exists. 808 @retval FALSE The Atapi device does not present. 809 810 **/ 811 BOOLEAN 812 DetectIDEController ( 813 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 814 IN UINTN DevicePosition 815 ) 816 { 817 UINT8 Channel; 818 EFI_STATUS Status; 819 UINT8 AtaCommand; 820 821 Channel = (UINT8) (DevicePosition / 2); 822 823 ASSERT (Channel < MAX_IDE_CHANNELS); 824 // 825 // Wait 31 seconds for BSY clear 826 // 827 Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000); 828 if (EFI_ERROR (Status)) { 829 return FALSE; 830 } 831 // 832 // Send 'check power' command for IDE device 833 // 834 AtaCommand = 0xE5; 835 Status = CheckPowerMode (AtapiBlkIoDev, DevicePosition, AtaCommand); 836 if ((Status == EFI_ABORTED) || (Status == EFI_SUCCESS)) { 837 return TRUE; 838 } 839 840 return FALSE; 841 } 842 843 /** 844 Wait specified time interval to poll for BSY bit clear in the Status Register. 845 846 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 847 @param[in] IdeIoRegisters A pointer to IDE IO registers. 848 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 849 850 @retval EFI_SUCCESS BSY bit is cleared in the specified time interval. 851 @retval EFI_TIMEOUT BSY bit is not cleared in the specified time interval. 852 853 **/ 854 EFI_STATUS 855 WaitForBSYClear ( 856 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 857 IN IDE_BASE_REGISTERS *IdeIoRegisters, 858 IN UINTN TimeoutInMilliSeconds 859 ) 860 { 861 UINTN Delay; 862 UINT16 StatusRegister; 863 UINT8 StatusValue; 864 865 StatusValue = 0; 866 867 StatusRegister = IdeIoRegisters->Reg.Status; 868 869 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 870 do { 871 StatusValue = IoRead8 (StatusRegister); 872 if ((StatusValue & ATA_STSREG_BSY) == 0x00) { 873 break; 874 } 875 MicroSecondDelay (250); 876 877 Delay--; 878 879 } while (Delay != 0); 880 881 if (Delay == 0) { 882 return EFI_TIMEOUT; 883 } 884 885 return EFI_SUCCESS; 886 } 887 888 /** 889 Wait specified time interval to poll for DRDY bit set in the Status register. 890 891 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 892 @param[in] IdeIoRegisters A pointer to IDE IO registers. 893 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 894 895 @retval EFI_SUCCESS DRDY bit is set in the specified time interval. 896 @retval EFI_TIMEOUT DRDY bit is not set in the specified time interval. 897 898 **/ 899 EFI_STATUS 900 DRDYReady ( 901 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 902 IN IDE_BASE_REGISTERS *IdeIoRegisters, 903 IN UINTN TimeoutInMilliSeconds 904 ) 905 { 906 UINTN Delay; 907 UINT16 StatusRegister; 908 UINT8 StatusValue; 909 UINT8 ErrValue; 910 911 StatusValue = 0; 912 913 StatusRegister = IdeIoRegisters->Reg.Status; 914 915 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 916 do { 917 StatusValue = IoRead8 (StatusRegister); 918 // 919 // BSY == 0 , DRDY == 1 920 // 921 if ((StatusValue & (ATA_STSREG_DRDY | ATA_STSREG_BSY)) == ATA_STSREG_DRDY) { 922 break; 923 } 924 925 if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_BSY)) == ATA_STSREG_ERR) { 926 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error); 927 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 928 return EFI_ABORTED; 929 } 930 } 931 932 MicroSecondDelay (250); 933 934 Delay--; 935 936 } while (Delay != 0); 937 938 if (Delay == 0) { 939 return EFI_TIMEOUT; 940 } 941 942 return EFI_SUCCESS; 943 } 944 945 /** 946 Wait specified time interval to poll for DRQ bit clear in the Status Register. 947 948 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 949 @param[in] IdeIoRegisters A pointer to IDE IO registers. 950 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 951 952 @retval EFI_SUCCESS DRQ bit is cleared in the specified time interval. 953 @retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval. 954 955 **/ 956 EFI_STATUS 957 DRQClear ( 958 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 959 IN IDE_BASE_REGISTERS *IdeIoRegisters, 960 IN UINTN TimeoutInMilliSeconds 961 ) 962 { 963 UINTN Delay; 964 UINT16 StatusRegister; 965 UINT8 StatusValue; 966 UINT8 ErrValue; 967 968 StatusValue = 0; 969 970 StatusRegister = IdeIoRegisters->Reg.Status; 971 972 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 973 do { 974 975 StatusValue = IoRead8 (StatusRegister); 976 977 // 978 // wait for BSY == 0 and DRQ == 0 979 // 980 if ((StatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) { 981 break; 982 } 983 984 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) { 985 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error); 986 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 987 return EFI_ABORTED; 988 } 989 } 990 991 MicroSecondDelay (250); 992 993 Delay--; 994 } while (Delay != 0); 995 996 if (Delay == 0) { 997 return EFI_TIMEOUT; 998 } 999 1000 return EFI_SUCCESS; 1001 } 1002 1003 /** 1004 Wait specified time interval to poll for DRQ bit clear in the Alternate Status Register. 1005 1006 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1007 @param[in] IdeIoRegisters A pointer to IDE IO registers. 1008 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 1009 1010 @retval EFI_SUCCESS DRQ bit is cleared in the specified time interval. 1011 @retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval. 1012 1013 **/ 1014 EFI_STATUS 1015 DRQClear2 ( 1016 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1017 IN IDE_BASE_REGISTERS *IdeIoRegisters, 1018 IN UINTN TimeoutInMilliSeconds 1019 ) 1020 { 1021 UINTN Delay; 1022 UINT16 AltStatusRegister; 1023 UINT8 AltStatusValue; 1024 UINT8 ErrValue; 1025 1026 AltStatusValue = 0; 1027 1028 AltStatusRegister = IdeIoRegisters->Alt.AltStatus; 1029 1030 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 1031 do { 1032 1033 AltStatusValue = IoRead8 (AltStatusRegister); 1034 1035 // 1036 // wait for BSY == 0 and DRQ == 0 1037 // 1038 if ((AltStatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) { 1039 break; 1040 } 1041 1042 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) { 1043 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error); 1044 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 1045 return EFI_ABORTED; 1046 } 1047 } 1048 1049 MicroSecondDelay (250); 1050 1051 Delay--; 1052 } while (Delay != 0); 1053 1054 if (Delay == 0) { 1055 return EFI_TIMEOUT; 1056 } 1057 1058 return EFI_SUCCESS; 1059 } 1060 1061 /** 1062 Wait specified time interval to poll for DRQ bit set in the Status Register. 1063 1064 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1065 @param[in] IdeIoRegisters A pointer to IDE IO registers. 1066 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 1067 1068 @retval EFI_SUCCESS DRQ bit is set in the specified time interval. 1069 @retval EFI_TIMEOUT DRQ bit is not set in the specified time interval. 1070 @retval EFI_ABORTED Operation Aborted. 1071 1072 **/ 1073 EFI_STATUS 1074 DRQReady ( 1075 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1076 IN IDE_BASE_REGISTERS *IdeIoRegisters, 1077 IN UINTN TimeoutInMilliSeconds 1078 ) 1079 { 1080 UINTN Delay; 1081 UINT16 StatusRegister; 1082 UINT8 StatusValue; 1083 UINT8 ErrValue; 1084 1085 StatusValue = 0; 1086 ErrValue = 0; 1087 1088 StatusRegister = IdeIoRegisters->Reg.Status; 1089 1090 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 1091 do { 1092 // 1093 // read Status Register will clear interrupt 1094 // 1095 StatusValue = IoRead8 (StatusRegister); 1096 1097 // 1098 // BSY==0,DRQ==1 1099 // 1100 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) { 1101 break; 1102 } 1103 1104 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) { 1105 1106 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error); 1107 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 1108 return EFI_ABORTED; 1109 } 1110 } 1111 MicroSecondDelay (250); 1112 1113 Delay--; 1114 } while (Delay != 0); 1115 1116 if (Delay == 0) { 1117 return EFI_TIMEOUT; 1118 } 1119 1120 return EFI_SUCCESS; 1121 } 1122 1123 /** 1124 Wait specified time interval to poll for DRQ bit set in the Alternate Status Register. 1125 1126 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1127 @param[in] IdeIoRegisters A pointer to IDE IO registers. 1128 @param[in] TimeoutInMilliSeconds Time specified in milliseconds. 1129 1130 @retval EFI_SUCCESS DRQ bit is set in the specified time interval. 1131 @retval EFI_TIMEOUT DRQ bit is not set in the specified time interval. 1132 @retval EFI_ABORTED Operation Aborted. 1133 1134 **/ 1135 EFI_STATUS 1136 DRQReady2 ( 1137 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1138 IN IDE_BASE_REGISTERS *IdeIoRegisters, 1139 IN UINTN TimeoutInMilliSeconds 1140 ) 1141 { 1142 UINTN Delay; 1143 UINT16 AltStatusRegister; 1144 UINT8 AltStatusValue; 1145 UINT8 ErrValue; 1146 1147 AltStatusValue = 0; 1148 1149 AltStatusRegister = IdeIoRegisters->Alt.AltStatus; 1150 1151 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1; 1152 do { 1153 1154 AltStatusValue = IoRead8 (AltStatusRegister); 1155 1156 // 1157 // BSY==0,DRQ==1 1158 // 1159 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) { 1160 break; 1161 } 1162 1163 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) { 1164 1165 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error); 1166 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) { 1167 return EFI_ABORTED; 1168 } 1169 } 1170 MicroSecondDelay (250); 1171 1172 Delay--; 1173 } while (Delay != 0); 1174 1175 if (Delay == 0) { 1176 return EFI_TIMEOUT; 1177 } 1178 1179 return EFI_SUCCESS; 1180 } 1181 1182 /** 1183 Check if there is an error in Status Register. 1184 1185 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1186 @param[in] StatusReg The address to IDE IO registers. 1187 1188 @retval EFI_SUCCESS Operation success. 1189 @retval EFI_DEVICE_ERROR Device error. 1190 1191 **/ 1192 EFI_STATUS 1193 CheckErrorStatus ( 1194 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1195 IN UINT16 StatusReg 1196 ) 1197 { 1198 UINT8 StatusValue; 1199 1200 StatusValue = IoRead8 (StatusReg); 1201 1202 if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_DWF | ATA_STSREG_CORR)) == 0) { 1203 1204 return EFI_SUCCESS; 1205 } 1206 1207 return EFI_DEVICE_ERROR; 1208 1209 } 1210 1211 /** 1212 Idendify Atapi devices. 1213 1214 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1215 @param[in] DevicePosition An integer to signify device position. 1216 1217 @retval EFI_SUCCESS Identify successfully. 1218 @retval EFI_DEVICE_ERROR Device cannot be identified successfully. 1219 1220 **/ 1221 EFI_STATUS 1222 ATAPIIdentify ( 1223 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1224 IN UINTN DevicePosition 1225 ) 1226 { 1227 ATAPI_IDENTIFY_DATA AtapiIdentifyData; 1228 UINT8 Channel; 1229 UINT8 Device; 1230 UINT16 StatusReg; 1231 UINT16 HeadReg; 1232 UINT16 CommandReg; 1233 UINT16 DataReg; 1234 UINT16 SectorCountReg; 1235 UINT16 SectorNumberReg; 1236 UINT16 CylinderLsbReg; 1237 UINT16 CylinderMsbReg; 1238 1239 UINT32 WordCount; 1240 UINT32 Increment; 1241 UINT32 Index; 1242 UINT32 ByteCount; 1243 UINT16 *Buffer16; 1244 1245 EFI_STATUS Status; 1246 1247 ByteCount = sizeof (AtapiIdentifyData); 1248 Buffer16 = (UINT16 *) &AtapiIdentifyData; 1249 1250 Channel = (UINT8) (DevicePosition / 2); 1251 Device = (UINT8) (DevicePosition % 2); 1252 1253 ASSERT (Channel < MAX_IDE_CHANNELS); 1254 1255 StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status; 1256 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head; 1257 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command; 1258 DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data; 1259 SectorCountReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount; 1260 SectorNumberReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorNumber; 1261 CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb; 1262 CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb; 1263 1264 // 1265 // Send ATAPI Identify Command to get IDENTIFY data. 1266 // 1267 if (WaitForBSYClear ( 1268 AtapiBlkIoDev, 1269 &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 1270 ATATIMEOUT 1271 ) != EFI_SUCCESS) { 1272 return EFI_DEVICE_ERROR; 1273 } 1274 // 1275 // select device via Head/Device register. 1276 // Before write Head/Device register, BSY and DRQ must be 0. 1277 // 1278 if (DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT) != EFI_SUCCESS) { 1279 return EFI_DEVICE_ERROR; 1280 } 1281 // 1282 // e0:1110,0000-- bit7 and bit5 are reserved bits. 1283 // bit6 set means LBA mode 1284 // 1285 IoWrite8 (HeadReg, (UINT8) ((Device << 4) | 0xe0)); 1286 1287 // 1288 // set all the command parameters 1289 // Before write to all the following registers, BSY and DRQ must be 0. 1290 // 1291 if (DRQClear2 ( 1292 AtapiBlkIoDev, 1293 &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 1294 ATATIMEOUT 1295 ) != EFI_SUCCESS) { 1296 1297 return EFI_DEVICE_ERROR; 1298 } 1299 1300 IoWrite8 (SectorCountReg, 0); 1301 IoWrite8 (SectorNumberReg, 0); 1302 IoWrite8 (CylinderLsbReg, 0); 1303 IoWrite8 (CylinderMsbReg, 0); 1304 1305 // 1306 // send command via Command Register 1307 // 1308 IoWrite8 (CommandReg, ATA_CMD_IDENTIFY_DEVICE); 1309 1310 // 1311 // According to PIO data in protocol, host can perform a series of reads to the 1312 // data register after each time device set DRQ ready; 1313 // The data size of "a series of read" is command specific. 1314 // For most ATA command, data size received from device will not exceed 1 sector, 1315 // hense the data size for "a series of read" can be the whole data size of one command request. 1316 // For ATA command such as Read Sector command, whole data size of one ATA command request is often larger 1317 // than 1 sector, according to the Read Sector command, the data size of "a series of read" is exactly 1318 // 1 sector. 1319 // Here for simplification reason, we specify the data size for "a series of read" to 1320 // 1 sector (256 words) if whole data size of one ATA commmand request is larger than 256 words. 1321 // 1322 Increment = 256; 1323 // 1324 // 256 words 1325 // 1326 WordCount = 0; 1327 // 1328 // WordCount is used to record bytes of currently transfered data 1329 // 1330 while (WordCount < ByteCount / 2) { 1331 // 1332 // Poll DRQ bit set, data transfer can be performed only when DRQ is ready. 1333 // 1334 Status = DRQReady2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT); 1335 if (Status != EFI_SUCCESS) { 1336 return Status; 1337 } 1338 1339 if (CheckErrorStatus (AtapiBlkIoDev, StatusReg) != EFI_SUCCESS) { 1340 1341 return EFI_DEVICE_ERROR; 1342 } 1343 // 1344 // Get the byte count for one series of read 1345 // 1346 if ((WordCount + Increment) > ByteCount / 2) { 1347 Increment = ByteCount / 2 - WordCount; 1348 } 1349 // 1350 // perform a series of read without check DRQ ready 1351 // 1352 for (Index = 0; Index < Increment; Index++) { 1353 *Buffer16++ = IoRead16 (DataReg); 1354 } 1355 1356 WordCount += Increment; 1357 1358 } 1359 // 1360 // while 1361 // 1362 if (DRQClear ( 1363 AtapiBlkIoDev, 1364 &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 1365 ATATIMEOUT 1366 ) != EFI_SUCCESS) { 1367 return CheckErrorStatus (AtapiBlkIoDev, StatusReg); 1368 } 1369 1370 return EFI_SUCCESS; 1371 1372 } 1373 1374 /** 1375 Sends out ATAPI Test Unit Ready Packet Command to the specified device 1376 to find out whether device is accessible. 1377 1378 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1379 @param[in] DevicePosition An integer to signify device position. 1380 1381 @retval EFI_SUCCESS TestUnit command executed successfully. 1382 @retval EFI_DEVICE_ERROR Device cannot be executed TestUnit command successfully. 1383 1384 **/ 1385 EFI_STATUS 1386 TestUnitReady ( 1387 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1388 IN UINTN DevicePosition 1389 ) 1390 { 1391 ATAPI_PACKET_COMMAND Packet; 1392 EFI_STATUS Status; 1393 1394 // 1395 // fill command packet 1396 // 1397 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 1398 Packet.TestUnitReady.opcode = ATA_CMD_TEST_UNIT_READY; 1399 1400 // 1401 // send command packet 1402 // 1403 Status = AtapiPacketCommandIn (AtapiBlkIoDev, DevicePosition, &Packet, NULL, 0, ATAPITIMEOUT); 1404 return Status; 1405 } 1406 1407 /** 1408 Send out ATAPI commands conforms to the Packet Command with PIO Data In Protocol. 1409 1410 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1411 @param[in] DevicePosition An integer to signify device position. 1412 @param[in] Packet A pointer to ATAPI command packet. 1413 @param[in] Buffer Buffer to contain requested transfer data from device. 1414 @param[in] ByteCount Requested transfer data length. 1415 @param[in] TimeoutInMilliSeconds Time out value, in unit of milliseconds. 1416 1417 @retval EFI_SUCCESS Command executed successfully. 1418 @retval EFI_DEVICE_ERROR Device cannot be executed command successfully. 1419 1420 **/ 1421 EFI_STATUS 1422 AtapiPacketCommandIn ( 1423 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1424 IN UINTN DevicePosition, 1425 IN ATAPI_PACKET_COMMAND *Packet, 1426 IN UINT16 *Buffer, 1427 IN UINT32 ByteCount, 1428 IN UINTN TimeoutInMilliSeconds 1429 ) 1430 { 1431 UINT8 Channel; 1432 UINT8 Device; 1433 UINT16 StatusReg; 1434 UINT16 HeadReg; 1435 UINT16 CommandReg; 1436 UINT16 FeatureReg; 1437 UINT16 CylinderLsbReg; 1438 UINT16 CylinderMsbReg; 1439 UINT16 DeviceControlReg; 1440 UINT16 DataReg; 1441 EFI_STATUS Status; 1442 UINT32 Count; 1443 UINT16 *CommandIndex; 1444 UINT16 *PtrBuffer; 1445 UINT32 Index; 1446 UINT8 StatusValue; 1447 UINT32 WordCount; 1448 1449 // 1450 // required transfer data in word unit. 1451 // 1452 UINT32 RequiredWordCount; 1453 1454 // 1455 // actual transfer data in word unit. 1456 // 1457 UINT32 ActualWordCount; 1458 1459 Channel = (UINT8) (DevicePosition / 2); 1460 Device = (UINT8) (DevicePosition % 2); 1461 1462 ASSERT (Channel < MAX_IDE_CHANNELS); 1463 1464 StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status; 1465 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head; 1466 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command; 1467 FeatureReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Feature; 1468 CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb; 1469 CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb; 1470 DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl; 1471 DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data; 1472 1473 // 1474 // Set all the command parameters by fill related registers. 1475 // Before write to all the following registers, BSY and DRQ must be 0. 1476 // 1477 if (DRQClear2 ( 1478 AtapiBlkIoDev, 1479 &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 1480 ATATIMEOUT 1481 ) != EFI_SUCCESS) { 1482 return EFI_DEVICE_ERROR; 1483 } 1484 // 1485 // Select device via Device/Head Register. 1486 // DEFAULT_CMD: 0xa0 (1010,0000) 1487 // 1488 IoWrite8 (HeadReg, (UINT8) ((Device << 4) | ATA_DEFAULT_CMD)); 1489 1490 // 1491 // No OVL; No DMA 1492 // 1493 IoWrite8 (FeatureReg, 0x00); 1494 1495 // 1496 // set the transfersize to MAX_ATAPI_BYTE_COUNT to let the device 1497 // determine how many data should be transfered. 1498 // 1499 IoWrite8 (CylinderLsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT & 0x00ff)); 1500 IoWrite8 (CylinderMsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT >> 8)); 1501 1502 // 1503 // DEFAULT_CTL:0x0a (0000,1010) 1504 // Disable interrupt 1505 // 1506 IoWrite8 (DeviceControlReg, ATA_DEFAULT_CTL); 1507 1508 // 1509 // Send Packet command to inform device 1510 // that the following data bytes are command packet. 1511 // 1512 IoWrite8 (CommandReg, ATA_CMD_PACKET); 1513 1514 Status = DRQReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds); 1515 if (Status != EFI_SUCCESS) { 1516 return Status; 1517 } 1518 // 1519 // Send out command packet 1520 // 1521 CommandIndex = Packet->Data16; 1522 for (Count = 0; Count < 6; Count++, CommandIndex++) { 1523 IoWrite16 (DataReg, *CommandIndex); 1524 MicroSecondDelay (10); 1525 } 1526 1527 StatusValue = IoRead8 (StatusReg); 1528 if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) { 1529 // 1530 // Trouble! Something's wrong here... Wait some time and return. 3 second is 1531 // supposed to be long enough for a device reset latency or error recovery 1532 // 1533 MicroSecondDelay (3000000); 1534 return EFI_DEVICE_ERROR; 1535 } 1536 1537 if (Buffer == NULL || ByteCount == 0) { 1538 return EFI_SUCCESS; 1539 } 1540 // 1541 // call PioReadWriteData() function to get 1542 // requested transfer data form device. 1543 // 1544 PtrBuffer = Buffer; 1545 RequiredWordCount = ByteCount / 2; 1546 // 1547 // ActuralWordCount means the word count of data really transfered. 1548 // 1549 ActualWordCount = 0; 1550 1551 Status = EFI_SUCCESS; 1552 while ((Status == EFI_SUCCESS) && (ActualWordCount < RequiredWordCount)) { 1553 // 1554 // before each data transfer stream, the host should poll DRQ bit ready, 1555 // which informs device is ready to transfer data. 1556 // 1557 if (DRQReady2 ( 1558 AtapiBlkIoDev, 1559 &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 1560 TimeoutInMilliSeconds 1561 ) != EFI_SUCCESS) { 1562 return CheckErrorStatus (AtapiBlkIoDev, StatusReg); 1563 } 1564 // 1565 // read Status Register will clear interrupt 1566 // 1567 StatusValue = IoRead8 (StatusReg); 1568 1569 // 1570 // get current data transfer size from Cylinder Registers. 1571 // 1572 WordCount = IoRead8 (CylinderMsbReg) << 8; 1573 WordCount = WordCount | IoRead8 (CylinderLsbReg); 1574 WordCount = WordCount & 0xffff; 1575 WordCount /= 2; 1576 1577 // 1578 // perform a series data In/Out. 1579 // 1580 for (Index = 0; (Index < WordCount) && (ActualWordCount < RequiredWordCount); Index++, ActualWordCount++) { 1581 1582 *PtrBuffer = IoRead16 (DataReg); 1583 1584 PtrBuffer++; 1585 1586 } 1587 1588 if (((ATAPI_REQUEST_SENSE_CMD *) Packet)->opcode == ATA_CMD_REQUEST_SENSE && ActualWordCount >= 4) { 1589 RequiredWordCount = MIN ( 1590 RequiredWordCount, 1591 (UINT32) (4 + (((ATAPI_REQUEST_SENSE_DATA *) Buffer)->addnl_sense_length / 2)) 1592 ); 1593 } 1594 1595 } 1596 // 1597 // After data transfer is completed, normally, DRQ bit should clear. 1598 // 1599 Status = DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds); 1600 if (Status != EFI_SUCCESS) { 1601 return EFI_DEVICE_ERROR; 1602 } 1603 // 1604 // read status register to check whether error happens. 1605 // 1606 Status = CheckErrorStatus (AtapiBlkIoDev, StatusReg); 1607 return Status; 1608 } 1609 1610 /** 1611 Sends out ATAPI Inquiry Packet Command to the specified device. 1612 This command will return INQUIRY data of the device. 1613 1614 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1615 @param[in] DevicePosition An integer to signify device position. 1616 @param[out] MediaInfo The media information of the specified block media. 1617 @param[out] MediaInfo2 The media information 2 of the specified block media. 1618 1619 @retval EFI_SUCCESS Command executed successfully. 1620 @retval EFI_DEVICE_ERROR Device cannot be executed command successfully. 1621 @retval EFI_UNSUPPORTED Unsupported device type. 1622 1623 **/ 1624 EFI_STATUS 1625 Inquiry ( 1626 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1627 IN UINTN DevicePosition, 1628 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo, 1629 OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2 1630 ) 1631 { 1632 ATAPI_PACKET_COMMAND Packet; 1633 EFI_STATUS Status; 1634 ATAPI_INQUIRY_DATA Idata; 1635 1636 // 1637 // prepare command packet for the ATAPI Inquiry Packet Command. 1638 // 1639 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 1640 ZeroMem (&Idata, sizeof (ATAPI_INQUIRY_DATA)); 1641 1642 Packet.Inquiry.opcode = ATA_CMD_INQUIRY; 1643 Packet.Inquiry.page_code = 0; 1644 Packet.Inquiry.allocation_length = (UINT8) sizeof (ATAPI_INQUIRY_DATA); 1645 1646 // 1647 // Send command packet and get requested Inquiry data. 1648 // 1649 Status = AtapiPacketCommandIn ( 1650 AtapiBlkIoDev, 1651 DevicePosition, 1652 &Packet, 1653 (UINT16 *) (&Idata), 1654 sizeof (ATAPI_INQUIRY_DATA), 1655 ATAPITIMEOUT 1656 //50 1657 ); 1658 1659 if (Status != EFI_SUCCESS) { 1660 return EFI_DEVICE_ERROR; 1661 } 1662 // 1663 // Identify device type via INQUIRY data. 1664 // 1665 switch (Idata.peripheral_type & 0x1f) { 1666 case 0x00: 1667 // 1668 // Magnetic Disk 1669 // 1670 MediaInfo->DeviceType = IdeLS120; 1671 MediaInfo->MediaPresent = FALSE; 1672 MediaInfo->LastBlock = 0; 1673 MediaInfo->BlockSize = 0x200; 1674 MediaInfo2->InterfaceType = MSG_ATAPI_DP; 1675 MediaInfo2->RemovableMedia = TRUE; 1676 MediaInfo2->MediaPresent = FALSE; 1677 MediaInfo2->ReadOnly = FALSE; 1678 MediaInfo2->BlockSize = 0x200; 1679 MediaInfo2->LastBlock = 0; 1680 break; 1681 1682 case 0x05: 1683 // 1684 // CD-ROM 1685 // 1686 MediaInfo->DeviceType = IdeCDROM; 1687 MediaInfo->MediaPresent = FALSE; 1688 MediaInfo->LastBlock = 0; 1689 MediaInfo->BlockSize = 0x800; 1690 MediaInfo2->InterfaceType = MSG_ATAPI_DP; 1691 MediaInfo2->RemovableMedia = TRUE; 1692 MediaInfo2->MediaPresent = FALSE; 1693 MediaInfo2->ReadOnly = TRUE; 1694 MediaInfo2->BlockSize = 0x200; 1695 MediaInfo2->LastBlock = 0; 1696 break; 1697 1698 default: 1699 return EFI_UNSUPPORTED; 1700 } 1701 1702 return EFI_SUCCESS; 1703 } 1704 1705 /** 1706 Used before read/write blocks from/to ATAPI device media. 1707 Since ATAPI device media is removable, it is necessary to detect 1708 whether media is present and get current present media's information. 1709 1710 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1711 @param[in] DevicePosition An integer to signify device position. 1712 @param[in, out] MediaInfo The media information of the specified block media. 1713 @param[in, out] MediaInfo2 The media information 2 of the specified block media. 1714 1715 @retval EFI_SUCCESS Command executed successfully. 1716 @retval EFI_DEVICE_ERROR Some device errors happen. 1717 @retval EFI_OUT_OF_RESOURCES Can not allocate required resources. 1718 1719 **/ 1720 EFI_STATUS 1721 DetectMedia ( 1722 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1723 IN UINTN DevicePosition, 1724 IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo, 1725 IN OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2 1726 ) 1727 { 1728 1729 UINTN Index; 1730 UINTN RetryNum; 1731 UINTN MaxRetryNum; 1732 ATAPI_REQUEST_SENSE_DATA *SenseBuffers; 1733 BOOLEAN NeedReadCapacity; 1734 BOOLEAN NeedRetry; 1735 EFI_STATUS Status; 1736 UINT8 SenseCounts; 1737 1738 SenseBuffers = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*SenseBuffers))); 1739 if (SenseBuffers == NULL) { 1740 return EFI_OUT_OF_RESOURCES; 1741 } 1742 1743 // 1744 // Test Unit Ready command is used to detect whether device is accessible, 1745 // the device will produce corresponding Sense data. 1746 // 1747 for (Index = 0; Index < 2; Index++) { 1748 1749 Status = TestUnitReady (AtapiBlkIoDev, DevicePosition); 1750 if (Status != EFI_SUCCESS) { 1751 Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE); 1752 1753 if (Status != EFI_SUCCESS) { 1754 ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE); 1755 } 1756 1757 } else { 1758 break; 1759 } 1760 } 1761 1762 SenseCounts = MAX_SENSE_KEY_COUNT; 1763 Status = EFI_SUCCESS; 1764 NeedReadCapacity = TRUE; 1765 1766 for (Index = 0; Index < 5; Index++) { 1767 SenseCounts = MAX_SENSE_KEY_COUNT; 1768 Status = RequestSense ( 1769 AtapiBlkIoDev, 1770 DevicePosition, 1771 SenseBuffers, 1772 &SenseCounts 1773 ); 1774 DEBUG ((EFI_D_INFO, "Atapi Request Sense Count is %d\n", SenseCounts)); 1775 if (IsDeviceStateUnclear (SenseBuffers, SenseCounts) || IsNoMedia (SenseBuffers, SenseCounts)) { 1776 // 1777 // We are not sure whether the media is present or not, try again 1778 // 1779 TestUnitReady (AtapiBlkIoDev, DevicePosition); 1780 } else { 1781 break; 1782 } 1783 } 1784 1785 if (Status == EFI_SUCCESS) { 1786 1787 if (IsNoMedia (SenseBuffers, SenseCounts)) { 1788 1789 NeedReadCapacity = FALSE; 1790 MediaInfo->MediaPresent = FALSE; 1791 MediaInfo->LastBlock = 0; 1792 MediaInfo2->MediaPresent = FALSE; 1793 MediaInfo2->LastBlock = 0; 1794 } 1795 1796 if (IsMediaError (SenseBuffers, SenseCounts)) { 1797 return EFI_DEVICE_ERROR; 1798 } 1799 } 1800 1801 if (NeedReadCapacity) { 1802 // 1803 // at most retry 5 times 1804 // 1805 MaxRetryNum = 5; 1806 RetryNum = 1; 1807 // 1808 // initial retry once 1809 // 1810 for (Index = 0; (Index < RetryNum) && (Index < MaxRetryNum); Index++) { 1811 1812 Status = ReadCapacity (AtapiBlkIoDev, DevicePosition, MediaInfo, MediaInfo2); 1813 MicroSecondDelay (200000); 1814 SenseCounts = MAX_SENSE_KEY_COUNT; 1815 1816 if (Status != EFI_SUCCESS) { 1817 1818 Status = RequestSense (AtapiBlkIoDev, DevicePosition, SenseBuffers, &SenseCounts); 1819 // 1820 // If Request Sense data failed, reset the device and retry. 1821 // 1822 if (Status != EFI_SUCCESS) { 1823 1824 Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE); 1825 // 1826 // if ATAPI soft reset fail, 1827 // use stronger reset mechanism -- ATA soft reset. 1828 // 1829 if (Status != EFI_SUCCESS) { 1830 ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE); 1831 } 1832 1833 RetryNum++; 1834 // 1835 // retry once more 1836 // 1837 continue; 1838 } 1839 // 1840 // No Media 1841 // 1842 if (IsNoMedia (SenseBuffers, SenseCounts)) { 1843 1844 MediaInfo->MediaPresent = FALSE; 1845 MediaInfo->LastBlock = 0; 1846 MediaInfo2->MediaPresent = FALSE; 1847 MediaInfo2->LastBlock = 0; 1848 break; 1849 } 1850 1851 if (IsMediaError (SenseBuffers, SenseCounts)) { 1852 return EFI_DEVICE_ERROR; 1853 } 1854 1855 if (!IsDriveReady (SenseBuffers, SenseCounts, &NeedRetry)) { 1856 // 1857 // Drive not ready: if NeedRetry, then retry once more; 1858 // else return error 1859 // 1860 if (NeedRetry) { 1861 RetryNum++; 1862 continue; 1863 } else { 1864 return EFI_DEVICE_ERROR; 1865 } 1866 } 1867 // 1868 // if read capacity fail not for above reasons, retry once more 1869 // 1870 RetryNum++; 1871 1872 } 1873 1874 } 1875 1876 } 1877 1878 return EFI_SUCCESS; 1879 } 1880 1881 /** 1882 Reset specified Atapi device. 1883 1884 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1885 @param[in] DevicePosition An integer to signify device position. 1886 @param[in] Extensive If TRUE, use ATA soft reset, otherwise use Atapi soft reset. 1887 1888 @retval EFI_SUCCESS Command executed successfully. 1889 @retval EFI_DEVICE_ERROR Some device errors happen. 1890 1891 **/ 1892 EFI_STATUS 1893 ResetDevice ( 1894 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1895 IN UINTN DevicePosition, 1896 IN BOOLEAN Extensive 1897 ) 1898 { 1899 UINT8 DevControl; 1900 UINT8 Command; 1901 UINT8 DeviceSelect; 1902 UINT16 DeviceControlReg; 1903 UINT16 CommandReg; 1904 UINT16 HeadReg; 1905 UINT8 Channel; 1906 UINT8 Device; 1907 1908 Channel = (UINT8) (DevicePosition / 2); 1909 Device = (UINT8) (DevicePosition % 2); 1910 1911 ASSERT (Channel < MAX_IDE_CHANNELS); 1912 1913 DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl; 1914 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command; 1915 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head; 1916 1917 if (Extensive) { 1918 1919 DevControl = 0; 1920 DevControl |= ATA_CTLREG_SRST; 1921 // 1922 // set SRST bit to initiate soft reset 1923 // 1924 DevControl |= BIT1; 1925 // 1926 // disable Interrupt 1927 // 1928 IoWrite8 (DeviceControlReg, DevControl); 1929 1930 // 1931 // Wait 10us 1932 // 1933 MicroSecondDelay (10); 1934 1935 // 1936 // Clear SRST bit 1937 // 1938 DevControl &= 0xfb; 1939 // 1940 // 0xfb:1111,1011 1941 // 1942 IoWrite8 (DeviceControlReg, DevControl); 1943 1944 // 1945 // slave device needs at most 31s to clear BSY 1946 // 1947 if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) == EFI_TIMEOUT) { 1948 return EFI_DEVICE_ERROR; 1949 } 1950 1951 } else { 1952 // 1953 // for ATAPI device, no need to wait DRDY ready after device selecting. 1954 // bit7 and bit5 are both set to 1 for backward compatibility 1955 // 1956 DeviceSelect = (UINT8) (((BIT7 | BIT5) | (Device << 4))); 1957 IoWrite8 (HeadReg, DeviceSelect); 1958 1959 Command = ATA_CMD_SOFT_RESET; 1960 IoWrite8 (CommandReg, Command); 1961 1962 // 1963 // BSY cleared is the only status return to the host by the device when reset is completed 1964 // slave device needs at most 31s to clear BSY 1965 // 1966 if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) != EFI_SUCCESS) { 1967 return EFI_DEVICE_ERROR; 1968 } 1969 // 1970 // stall 5 seconds to make the device status stable 1971 // 1972 MicroSecondDelay (STALL_1_SECONDS * 5); 1973 } 1974 1975 return EFI_SUCCESS; 1976 1977 } 1978 1979 /** 1980 Sends out ATAPI Request Sense Packet Command to the specified device. 1981 1982 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 1983 @param[in] DevicePosition An integer to signify device position. 1984 @param[in] SenseBuffers Pointer to sense buffer. 1985 @param[in, out] SenseCounts Length of sense buffer. 1986 1987 @retval EFI_SUCCESS Command executed successfully. 1988 @retval EFI_DEVICE_ERROR Some device errors happen. 1989 1990 **/ 1991 EFI_STATUS 1992 RequestSense ( 1993 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 1994 IN UINTN DevicePosition, 1995 IN ATAPI_REQUEST_SENSE_DATA *SenseBuffers, 1996 IN OUT UINT8 *SenseCounts 1997 ) 1998 { 1999 EFI_STATUS Status; 2000 ATAPI_REQUEST_SENSE_DATA *Sense; 2001 UINT16 *Ptr; 2002 BOOLEAN SenseReq; 2003 ATAPI_PACKET_COMMAND Packet; 2004 2005 ZeroMem (SenseBuffers, sizeof (ATAPI_REQUEST_SENSE_DATA) * (*SenseCounts)); 2006 // 2007 // fill command packet for Request Sense Packet Command 2008 // 2009 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 2010 Packet.RequestSence.opcode = ATA_CMD_REQUEST_SENSE; 2011 Packet.RequestSence.allocation_length = (UINT8) sizeof (ATAPI_REQUEST_SENSE_DATA); 2012 2013 Ptr = (UINT16 *) SenseBuffers; 2014 // 2015 // initialize pointer 2016 // 2017 *SenseCounts = 0; 2018 // 2019 // request sense data from device continiously until no sense data exists in the device. 2020 // 2021 for (SenseReq = TRUE; SenseReq;) { 2022 2023 Sense = (ATAPI_REQUEST_SENSE_DATA *) Ptr; 2024 2025 // 2026 // send out Request Sense Packet Command and get one Sense data form device 2027 // 2028 Status = AtapiPacketCommandIn ( 2029 AtapiBlkIoDev, 2030 DevicePosition, 2031 &Packet, 2032 Ptr, 2033 sizeof (ATAPI_REQUEST_SENSE_DATA), 2034 ATAPITIMEOUT 2035 ); 2036 // 2037 // failed to get Sense data 2038 // 2039 if (Status != EFI_SUCCESS) { 2040 if (*SenseCounts == 0) { 2041 return EFI_DEVICE_ERROR; 2042 } else { 2043 return EFI_SUCCESS; 2044 } 2045 } 2046 2047 (*SenseCounts)++; 2048 2049 if (*SenseCounts > MAX_SENSE_KEY_COUNT) { 2050 return EFI_SUCCESS; 2051 } 2052 // 2053 // We limit MAX sense data count to 20 in order to avoid dead loop. Some 2054 // incompatible ATAPI devices don't retrive NO_SENSE when there is no media. 2055 // In this case, dead loop occurs if we don't have a gatekeeper. 20 is 2056 // supposed to be large enough for any ATAPI device. 2057 // 2058 if ((Sense->sense_key != ATA_SK_NO_SENSE) && ((*SenseCounts) < 20)) { 2059 2060 Ptr += sizeof (ATAPI_REQUEST_SENSE_DATA) / 2; 2061 // 2062 // Ptr is word based pointer 2063 // 2064 } else { 2065 // 2066 // when no sense key, skip out the loop 2067 // 2068 SenseReq = FALSE; 2069 } 2070 } 2071 2072 return EFI_SUCCESS; 2073 } 2074 2075 /** 2076 Sends out ATAPI Read Capacity Packet Command to the specified device. 2077 This command will return the information regarding the capacity of the 2078 media in the device. 2079 2080 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 2081 @param[in] DevicePosition An integer to signify device position. 2082 @param[in, out] MediaInfo The media information of the specified block media. 2083 @param[in, out] MediaInfo2 The media information 2 of the specified block media. 2084 2085 @retval EFI_SUCCESS Command executed successfully. 2086 @retval EFI_DEVICE_ERROR Some device errors happen. 2087 2088 **/ 2089 EFI_STATUS 2090 ReadCapacity ( 2091 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 2092 IN UINTN DevicePosition, 2093 IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo, 2094 IN OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2 2095 ) 2096 { 2097 EFI_STATUS Status; 2098 ATAPI_PACKET_COMMAND Packet; 2099 2100 // 2101 // used for capacity data returned from ATAPI device 2102 // 2103 ATAPI_READ_CAPACITY_DATA Data; 2104 ATAPI_READ_FORMAT_CAPACITY_DATA FormatData; 2105 2106 ZeroMem (&Data, sizeof (Data)); 2107 ZeroMem (&FormatData, sizeof (FormatData)); 2108 2109 if (MediaInfo->DeviceType == IdeCDROM) { 2110 2111 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 2112 Packet.Inquiry.opcode = ATA_CMD_READ_CAPACITY; 2113 Status = AtapiPacketCommandIn ( 2114 AtapiBlkIoDev, 2115 DevicePosition, 2116 &Packet, 2117 (UINT16 *) (&Data), 2118 sizeof (ATAPI_READ_CAPACITY_DATA), 2119 ATAPITIMEOUT 2120 ); 2121 2122 } else { 2123 // 2124 // DeviceType == IdeLS120 2125 // 2126 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 2127 Packet.ReadFormatCapacity.opcode = ATA_CMD_READ_FORMAT_CAPACITY; 2128 Packet.ReadFormatCapacity.allocation_length_lo = 12; 2129 Status = AtapiPacketCommandIn ( 2130 AtapiBlkIoDev, 2131 DevicePosition, 2132 &Packet, 2133 (UINT16 *) (&FormatData), 2134 sizeof (ATAPI_READ_FORMAT_CAPACITY_DATA), 2135 ATAPITIMEOUT*10 2136 ); 2137 } 2138 2139 if (Status == EFI_SUCCESS) { 2140 2141 if (MediaInfo->DeviceType == IdeCDROM) { 2142 2143 MediaInfo->LastBlock = (Data.LastLba3 << 24) | (Data.LastLba2 << 16) | (Data.LastLba1 << 8) | Data.LastLba0; 2144 MediaInfo->MediaPresent = TRUE; 2145 // 2146 // Because the user data portion in the sector of the Data CD supported 2147 // is always 800h 2148 // 2149 MediaInfo->BlockSize = 0x800; 2150 2151 MediaInfo2->LastBlock = MediaInfo->LastBlock; 2152 MediaInfo2->MediaPresent = MediaInfo->MediaPresent; 2153 MediaInfo2->BlockSize = (UINT32)MediaInfo->BlockSize; 2154 } 2155 2156 if (MediaInfo->DeviceType == IdeLS120) { 2157 2158 if (FormatData.DesCode == 3) { 2159 MediaInfo->MediaPresent = FALSE; 2160 MediaInfo->LastBlock = 0; 2161 MediaInfo2->MediaPresent = FALSE; 2162 MediaInfo2->LastBlock = 0; 2163 } else { 2164 MediaInfo->LastBlock = (FormatData.LastLba3 << 24) | 2165 (FormatData.LastLba2 << 16) | 2166 (FormatData.LastLba1 << 8) | 2167 FormatData.LastLba0; 2168 MediaInfo->LastBlock--; 2169 2170 MediaInfo->MediaPresent = TRUE; 2171 2172 MediaInfo->BlockSize = 0x200; 2173 2174 MediaInfo2->LastBlock = MediaInfo->LastBlock; 2175 MediaInfo2->MediaPresent = MediaInfo->MediaPresent; 2176 MediaInfo2->BlockSize = (UINT32)MediaInfo->BlockSize; 2177 2178 } 2179 } 2180 2181 return EFI_SUCCESS; 2182 2183 } else { 2184 return EFI_DEVICE_ERROR; 2185 } 2186 } 2187 2188 /** 2189 Perform read from disk in block unit. 2190 2191 @param[in] AtapiBlkIoDev A pointer to atapi block IO device. 2192 @param[in] DevicePosition An integer to signify device position. 2193 @param[in] Buffer Buffer to contain read data. 2194 @param[in] StartLba Starting LBA address. 2195 @param[in] NumberOfBlocks Number of blocks to read. 2196 @param[in] BlockSize Size of each block. 2197 2198 @retval EFI_SUCCESS Command executed successfully. 2199 @retval EFI_DEVICE_ERROR Some device errors happen. 2200 2201 **/ 2202 EFI_STATUS 2203 ReadSectors ( 2204 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev, 2205 IN UINTN DevicePosition, 2206 IN VOID *Buffer, 2207 IN EFI_PEI_LBA StartLba, 2208 IN UINTN NumberOfBlocks, 2209 IN UINTN BlockSize 2210 ) 2211 { 2212 2213 ATAPI_PACKET_COMMAND Packet; 2214 ATAPI_READ10_CMD *Read10Packet; 2215 EFI_STATUS Status; 2216 UINTN BlocksRemaining; 2217 UINT32 Lba32; 2218 UINT32 ByteCount; 2219 UINT16 SectorCount; 2220 VOID *PtrBuffer; 2221 UINT16 MaxBlock; 2222 2223 // 2224 // fill command packet for Read(10) command 2225 // 2226 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND)); 2227 Read10Packet = &Packet.Read10; 2228 Lba32 = (UINT32) StartLba; 2229 PtrBuffer = Buffer; 2230 2231 // 2232 // limit the data bytes that can be transfered by one Read(10) Command 2233 // 2234 MaxBlock = (UINT16) (0x10000 / BlockSize); 2235 // 2236 // (64k bytes) 2237 // 2238 BlocksRemaining = NumberOfBlocks; 2239 2240 Status = EFI_SUCCESS; 2241 while (BlocksRemaining > 0) { 2242 2243 if (BlocksRemaining <= MaxBlock) { 2244 SectorCount = (UINT16) BlocksRemaining; 2245 } else { 2246 SectorCount = MaxBlock; 2247 } 2248 // 2249 // fill the Packet data sturcture 2250 // 2251 Read10Packet->opcode = ATA_CMD_READ_10; 2252 2253 // 2254 // Lba0 ~ Lba3 specify the start logical block address of the data transfer. 2255 // Lba0 is MSB, Lba3 is LSB 2256 // 2257 Read10Packet->Lba3 = (UINT8) (Lba32 & 0xff); 2258 Read10Packet->Lba2 = (UINT8) (Lba32 >> 8); 2259 Read10Packet->Lba1 = (UINT8) (Lba32 >> 16); 2260 Read10Packet->Lba0 = (UINT8) (Lba32 >> 24); 2261 2262 // 2263 // TranLen0 ~ TranLen1 specify the transfer length in block unit. 2264 // TranLen0 is MSB, TranLen is LSB 2265 // 2266 Read10Packet->TranLen1 = (UINT8) (SectorCount & 0xff); 2267 Read10Packet->TranLen0 = (UINT8) (SectorCount >> 8); 2268 2269 ByteCount = (UINT32) (SectorCount * BlockSize); 2270 2271 Status = AtapiPacketCommandIn ( 2272 AtapiBlkIoDev, 2273 DevicePosition, 2274 &Packet, 2275 (UINT16 *) PtrBuffer, 2276 ByteCount, 2277 ATAPILONGTIMEOUT 2278 ); 2279 if (Status != EFI_SUCCESS) { 2280 return Status; 2281 } 2282 2283 Lba32 += SectorCount; 2284 PtrBuffer = (UINT8 *) PtrBuffer + SectorCount * BlockSize; 2285 BlocksRemaining -= SectorCount; 2286 } 2287 2288 return Status; 2289 } 2290 2291 /** 2292 Check if there is media according to sense data. 2293 2294 @param[in] SenseData Pointer to sense data. 2295 @param[in] SenseCounts Count of sense data. 2296 2297 @retval TRUE No media 2298 @retval FALSE Media exists 2299 2300 **/ 2301 BOOLEAN 2302 IsNoMedia ( 2303 IN ATAPI_REQUEST_SENSE_DATA *SenseData, 2304 IN UINTN SenseCounts 2305 ) 2306 { 2307 ATAPI_REQUEST_SENSE_DATA *SensePtr; 2308 UINTN Index; 2309 BOOLEAN IsNoMedia; 2310 2311 IsNoMedia = FALSE; 2312 2313 SensePtr = SenseData; 2314 2315 for (Index = 0; Index < SenseCounts; Index++) { 2316 2317 if ((SensePtr->sense_key == ATA_SK_NOT_READY) && (SensePtr->addnl_sense_code == ATA_ASC_NO_MEDIA)) { 2318 IsNoMedia = TRUE; 2319 } 2320 2321 SensePtr++; 2322 } 2323 2324 return IsNoMedia; 2325 } 2326 2327 /** 2328 Check if device state is unclear according to sense data. 2329 2330 @param[in] SenseData Pointer to sense data. 2331 @param[in] SenseCounts Count of sense data. 2332 2333 @retval TRUE Device state is unclear 2334 @retval FALSE Device state is clear 2335 2336 **/ 2337 BOOLEAN 2338 IsDeviceStateUnclear ( 2339 IN ATAPI_REQUEST_SENSE_DATA *SenseData, 2340 IN UINTN SenseCounts 2341 ) 2342 { 2343 ATAPI_REQUEST_SENSE_DATA *SensePtr; 2344 UINTN Index; 2345 BOOLEAN Unclear; 2346 2347 Unclear = FALSE; 2348 2349 SensePtr = SenseData; 2350 2351 for (Index = 0; Index < SenseCounts; Index++) { 2352 2353 if (SensePtr->sense_key == 0x06) { 2354 // 2355 // Sense key is 0x06 means the device is just be reset or media just 2356 // changed. The current state of the device is unclear. 2357 // 2358 Unclear = TRUE; 2359 break; 2360 } 2361 2362 SensePtr++; 2363 } 2364 2365 return Unclear; 2366 } 2367 2368 /** 2369 Check if there is media error according to sense data. 2370 2371 @param[in] SenseData Pointer to sense data. 2372 @param[in] SenseCounts Count of sense data. 2373 2374 @retval TRUE Media error 2375 @retval FALSE No media error 2376 2377 **/ 2378 BOOLEAN 2379 IsMediaError ( 2380 IN ATAPI_REQUEST_SENSE_DATA *SenseData, 2381 IN UINTN SenseCounts 2382 ) 2383 { 2384 ATAPI_REQUEST_SENSE_DATA *SensePtr; 2385 UINTN Index; 2386 BOOLEAN IsError; 2387 2388 IsError = FALSE; 2389 2390 SensePtr = SenseData; 2391 2392 for (Index = 0; Index < SenseCounts; Index++) { 2393 2394 switch (SensePtr->sense_key) { 2395 2396 case ATA_SK_MEDIUM_ERROR: 2397 switch (SensePtr->addnl_sense_code) { 2398 case ATA_ASC_MEDIA_ERR1: 2399 // 2400 // fall through 2401 // 2402 case ATA_ASC_MEDIA_ERR2: 2403 // 2404 // fall through 2405 // 2406 case ATA_ASC_MEDIA_ERR3: 2407 // 2408 // fall through 2409 // 2410 case ATA_ASC_MEDIA_ERR4: 2411 IsError = TRUE; 2412 break; 2413 2414 default: 2415 break; 2416 } 2417 2418 break; 2419 2420 case ATA_SK_NOT_READY: 2421 switch (SensePtr->addnl_sense_code) { 2422 case ATA_ASC_MEDIA_UPSIDE_DOWN: 2423 IsError = TRUE; 2424 break; 2425 2426 default: 2427 break; 2428 } 2429 break; 2430 2431 default: 2432 break; 2433 } 2434 2435 SensePtr++; 2436 } 2437 2438 return IsError; 2439 } 2440 2441 /** 2442 Check if drive is ready according to sense data. 2443 2444 @param[in] SenseData Pointer to sense data. 2445 @param[in] SenseCounts Count of sense data. 2446 @param[out] NeedRetry Indicate if retry is needed. 2447 2448 @retval TRUE Drive ready 2449 @retval FALSE Drive not ready 2450 2451 **/ 2452 BOOLEAN 2453 IsDriveReady ( 2454 IN ATAPI_REQUEST_SENSE_DATA *SenseData, 2455 IN UINTN SenseCounts, 2456 OUT BOOLEAN *NeedRetry 2457 ) 2458 { 2459 ATAPI_REQUEST_SENSE_DATA *SensePtr; 2460 UINTN Index; 2461 BOOLEAN IsReady; 2462 2463 IsReady = TRUE; 2464 *NeedRetry = FALSE; 2465 2466 SensePtr = SenseData; 2467 2468 for (Index = 0; Index < SenseCounts; Index++) { 2469 2470 switch (SensePtr->sense_key) { 2471 2472 case ATA_SK_NOT_READY: 2473 switch (SensePtr->addnl_sense_code) { 2474 case ATA_ASC_NOT_READY: 2475 switch (SensePtr->addnl_sense_code_qualifier) { 2476 case ATA_ASCQ_IN_PROGRESS: 2477 IsReady = FALSE; 2478 *NeedRetry = TRUE; 2479 break; 2480 2481 default: 2482 IsReady = FALSE; 2483 *NeedRetry = FALSE; 2484 break; 2485 } 2486 break; 2487 2488 default: 2489 break; 2490 } 2491 break; 2492 2493 default: 2494 break; 2495 } 2496 2497 SensePtr++; 2498 } 2499 2500 return IsReady; 2501 } 2502
