1 /** @file 2 3 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR> 4 This program and the accompanying materials 5 are licensed and made available under the terms and conditions of the BSD License 6 which accompanies this distribution. The full text of the license may be found at 7 http://opensource.org/licenses/bsd-license.php 8 9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 11 12 **/ 13 14 #include "SdBlockIoPei.h" 15 16 // 17 // Template for SD HC Slot Data. 18 // 19 SD_PEIM_HC_SLOT gSdHcSlotTemplate = { 20 SD_PEIM_SLOT_SIG, // Signature 21 { // Media 22 MSG_SD_DP, 23 FALSE, 24 TRUE, 25 FALSE, 26 0x200, 27 0 28 }, 29 0, // SdHcBase 30 { // Capability 31 0, 32 }, 33 { // Csd 34 0, 35 }, 36 TRUE, // SectorAddressing 37 NULL // Private 38 }; 39 40 // 41 // Template for SD HC Private Data. 42 // 43 SD_PEIM_HC_PRIVATE_DATA gSdHcPrivateTemplate = { 44 SD_PEIM_SIG, // Signature 45 NULL, // Pool 46 { // BlkIoPpi 47 SdBlockIoPeimGetDeviceNo, 48 SdBlockIoPeimGetMediaInfo, 49 SdBlockIoPeimReadBlocks 50 }, 51 { // BlkIo2Ppi 52 EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION, 53 SdBlockIoPeimGetDeviceNo2, 54 SdBlockIoPeimGetMediaInfo2, 55 SdBlockIoPeimReadBlocks2 56 }, 57 { // BlkIoPpiList 58 EFI_PEI_PPI_DESCRIPTOR_PPI, 59 &gEfiPeiVirtualBlockIoPpiGuid, 60 NULL 61 }, 62 { // BlkIo2PpiList 63 EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST, 64 &gEfiPeiVirtualBlockIo2PpiGuid, 65 NULL 66 }, 67 { // Slot 68 { 69 0, 70 }, 71 { 72 0, 73 }, 74 { 75 0, 76 }, 77 { 78 0, 79 }, 80 { 81 0, 82 }, 83 { 84 0, 85 } 86 }, 87 0, // SlotNum 88 0 // TotalBlkIoDevices 89 }; 90 /** 91 Gets the count of block I/O devices that one specific block driver detects. 92 93 This function is used for getting the count of block I/O devices that one 94 specific block driver detects. To the PEI ATAPI driver, it returns the number 95 of all the detected ATAPI devices it detects during the enumeration process. 96 To the PEI legacy floppy driver, it returns the number of all the legacy 97 devices it finds during its enumeration process. If no device is detected, 98 then the function will return zero. 99 100 @param[in] PeiServices General-purpose services that are available 101 to every PEIM. 102 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI 103 instance. 104 @param[out] NumberBlockDevices The number of block I/O devices discovered. 105 106 @retval EFI_SUCCESS The operation performed successfully. 107 108 **/ 109 EFI_STATUS 110 EFIAPI 111 SdBlockIoPeimGetDeviceNo ( 112 IN EFI_PEI_SERVICES **PeiServices, 113 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 114 OUT UINTN *NumberBlockDevices 115 ) 116 { 117 SD_PEIM_HC_PRIVATE_DATA *Private; 118 119 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This); 120 *NumberBlockDevices = Private->TotalBlkIoDevices; 121 return EFI_SUCCESS; 122 } 123 124 /** 125 Gets a block device's media information. 126 127 This function will provide the caller with the specified block device's media 128 information. If the media changes, calling this function will update the media 129 information accordingly. 130 131 @param[in] PeiServices General-purpose services that are available to every 132 PEIM 133 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance. 134 @param[in] DeviceIndex Specifies the block device to which the function wants 135 to talk. Because the driver that implements Block I/O 136 PPIs will manage multiple block devices, the PPIs that 137 want to talk to a single device must specify the 138 device index that was assigned during the enumeration 139 process. This index is a number from one to 140 NumberBlockDevices. 141 @param[out] MediaInfo The media information of the specified block media. 142 The caller is responsible for the ownership of this 143 data structure. 144 145 @par Note: 146 The MediaInfo structure describes an enumeration of possible block device 147 types. This enumeration exists because no device paths are actually passed 148 across interfaces that describe the type or class of hardware that is publishing 149 the block I/O interface. This enumeration will allow for policy decisions 150 in the Recovery PEIM, such as "Try to recover from legacy floppy first, 151 LS-120 second, CD-ROM third." If there are multiple partitions abstracted 152 by a given device type, they should be reported in ascending order; this 153 order also applies to nested partitions, such as legacy MBR, where the 154 outermost partitions would have precedence in the reporting order. The 155 same logic applies to systems such as IDE that have precedence relationships 156 like "Master/Slave" or "Primary/Secondary". The master device should be 157 reported first, the slave second. 158 159 @retval EFI_SUCCESS Media information about the specified block device 160 was obtained successfully. 161 @retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware 162 error. 163 164 **/ 165 EFI_STATUS 166 EFIAPI 167 SdBlockIoPeimGetMediaInfo ( 168 IN EFI_PEI_SERVICES **PeiServices, 169 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 170 IN UINTN DeviceIndex, 171 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo 172 ) 173 { 174 SD_PEIM_HC_PRIVATE_DATA *Private; 175 176 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This); 177 178 if ((DeviceIndex == 0) || (DeviceIndex > Private->TotalBlkIoDevices)) { 179 return EFI_INVALID_PARAMETER; 180 } 181 182 MediaInfo->DeviceType = SD; 183 MediaInfo->MediaPresent = TRUE; 184 MediaInfo->LastBlock = (UINTN)Private->Slot[DeviceIndex - 1].Media.LastBlock; 185 MediaInfo->BlockSize = Private->Slot[DeviceIndex - 1].Media.BlockSize; 186 187 return EFI_SUCCESS; 188 } 189 190 /** 191 Reads the requested number of blocks from the specified block device. 192 193 The function reads the requested number of blocks from the device. All the 194 blocks are read, or an error is returned. If there is no media in the device, 195 the function returns EFI_NO_MEDIA. 196 197 @param[in] PeiServices General-purpose services that are available to 198 every PEIM. 199 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance. 200 @param[in] DeviceIndex Specifies the block device to which the function wants 201 to talk. Because the driver that implements Block I/O 202 PPIs will manage multiple block devices, PPIs that 203 want to talk to a single device must specify the device 204 index that was assigned during the enumeration process. 205 This index is a number from one to NumberBlockDevices. 206 @param[in] StartLBA The starting logical block address (LBA) to read from 207 on the device 208 @param[in] BufferSize The size of the Buffer in bytes. This number must be 209 a multiple of the intrinsic block size of the device. 210 @param[out] Buffer A pointer to the destination buffer for the data. 211 The caller is responsible for the ownership of the 212 buffer. 213 214 @retval EFI_SUCCESS The data was read correctly from the device. 215 @retval EFI_DEVICE_ERROR The device reported an error while attempting 216 to perform the read operation. 217 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not 218 valid, or the buffer is not properly aligned. 219 @retval EFI_NO_MEDIA There is no media in the device. 220 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of 221 the intrinsic block size of the device. 222 223 **/ 224 EFI_STATUS 225 EFIAPI 226 SdBlockIoPeimReadBlocks ( 227 IN EFI_PEI_SERVICES **PeiServices, 228 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This, 229 IN UINTN DeviceIndex, 230 IN EFI_PEI_LBA StartLBA, 231 IN UINTN BufferSize, 232 OUT VOID *Buffer 233 ) 234 { 235 EFI_STATUS Status; 236 UINT32 BlockSize; 237 UINTN NumberOfBlocks; 238 SD_PEIM_HC_PRIVATE_DATA *Private; 239 UINTN Remaining; 240 UINT32 MaxBlock; 241 242 Status = EFI_SUCCESS; 243 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS (This); 244 245 // 246 // Check parameters 247 // 248 if (Buffer == NULL) { 249 return EFI_INVALID_PARAMETER; 250 } 251 252 if (BufferSize == 0) { 253 return EFI_SUCCESS; 254 } 255 256 if ((DeviceIndex == 0) || (DeviceIndex > Private->TotalBlkIoDevices)) { 257 return EFI_INVALID_PARAMETER; 258 } 259 260 BlockSize = Private->Slot[DeviceIndex - 1].Media.BlockSize; 261 if (BufferSize % BlockSize != 0) { 262 return EFI_BAD_BUFFER_SIZE; 263 } 264 265 if (StartLBA > Private->Slot[DeviceIndex - 1].Media.LastBlock) { 266 return EFI_INVALID_PARAMETER; 267 } 268 269 NumberOfBlocks = BufferSize / BlockSize; 270 271 // 272 // Start to execute data transfer. The max block number in single cmd is 65535 blocks. 273 // 274 Remaining = NumberOfBlocks; 275 MaxBlock = 0xFFFF; 276 277 while (Remaining > 0) { 278 if (Remaining <= MaxBlock) { 279 NumberOfBlocks = Remaining; 280 } else { 281 NumberOfBlocks = MaxBlock; 282 } 283 284 BufferSize = NumberOfBlocks * BlockSize; 285 if (NumberOfBlocks != 1) { 286 Status = SdPeimRwMultiBlocks (&Private->Slot[DeviceIndex - 1], StartLBA, BlockSize, Buffer, BufferSize, TRUE); 287 } else { 288 Status = SdPeimRwSingleBlock (&Private->Slot[DeviceIndex - 1], StartLBA, BlockSize, Buffer, BufferSize, TRUE); 289 } 290 if (EFI_ERROR (Status)) { 291 return Status; 292 } 293 294 StartLBA += NumberOfBlocks; 295 Buffer = (UINT8*)Buffer + BufferSize; 296 Remaining -= NumberOfBlocks; 297 } 298 return Status; 299 } 300 301 /** 302 Gets the count of block I/O devices that one specific block driver detects. 303 304 This function is used for getting the count of block I/O devices that one 305 specific block driver detects. To the PEI ATAPI driver, it returns the number 306 of all the detected ATAPI devices it detects during the enumeration process. 307 To the PEI legacy floppy driver, it returns the number of all the legacy 308 devices it finds during its enumeration process. If no device is detected, 309 then the function will return zero. 310 311 @param[in] PeiServices General-purpose services that are available 312 to every PEIM. 313 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI 314 instance. 315 @param[out] NumberBlockDevices The number of block I/O devices discovered. 316 317 @retval EFI_SUCCESS The operation performed successfully. 318 319 **/ 320 EFI_STATUS 321 EFIAPI 322 SdBlockIoPeimGetDeviceNo2 ( 323 IN EFI_PEI_SERVICES **PeiServices, 324 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 325 OUT UINTN *NumberBlockDevices 326 ) 327 { 328 SD_PEIM_HC_PRIVATE_DATA *Private; 329 330 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This); 331 *NumberBlockDevices = Private->TotalBlkIoDevices; 332 333 return EFI_SUCCESS; 334 } 335 336 /** 337 Gets a block device's media information. 338 339 This function will provide the caller with the specified block device's media 340 information. If the media changes, calling this function will update the media 341 information accordingly. 342 343 @param[in] PeiServices General-purpose services that are available to every 344 PEIM 345 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance. 346 @param[in] DeviceIndex Specifies the block device to which the function wants 347 to talk. Because the driver that implements Block I/O 348 PPIs will manage multiple block devices, the PPIs that 349 want to talk to a single device must specify the 350 device index that was assigned during the enumeration 351 process. This index is a number from one to 352 NumberBlockDevices. 353 @param[out] MediaInfo The media information of the specified block media. 354 The caller is responsible for the ownership of this 355 data structure. 356 357 @par Note: 358 The MediaInfo structure describes an enumeration of possible block device 359 types. This enumeration exists because no device paths are actually passed 360 across interfaces that describe the type or class of hardware that is publishing 361 the block I/O interface. This enumeration will allow for policy decisions 362 in the Recovery PEIM, such as "Try to recover from legacy floppy first, 363 LS-120 second, CD-ROM third." If there are multiple partitions abstracted 364 by a given device type, they should be reported in ascending order; this 365 order also applies to nested partitions, such as legacy MBR, where the 366 outermost partitions would have precedence in the reporting order. The 367 same logic applies to systems such as IDE that have precedence relationships 368 like "Master/Slave" or "Primary/Secondary". The master device should be 369 reported first, the slave second. 370 371 @retval EFI_SUCCESS Media information about the specified block device 372 was obtained successfully. 373 @retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware 374 error. 375 376 **/ 377 EFI_STATUS 378 EFIAPI 379 SdBlockIoPeimGetMediaInfo2 ( 380 IN EFI_PEI_SERVICES **PeiServices, 381 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 382 IN UINTN DeviceIndex, 383 OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo 384 ) 385 { 386 EFI_STATUS Status; 387 SD_PEIM_HC_PRIVATE_DATA *Private; 388 EFI_PEI_BLOCK_IO_MEDIA Media; 389 390 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This); 391 392 Status = SdBlockIoPeimGetMediaInfo ( 393 PeiServices, 394 &Private->BlkIoPpi, 395 DeviceIndex, 396 &Media 397 ); 398 if (EFI_ERROR (Status)) { 399 return Status; 400 } 401 402 CopyMem (MediaInfo, &(Private->Slot[DeviceIndex - 1].Media), sizeof (EFI_PEI_BLOCK_IO2_MEDIA)); 403 return EFI_SUCCESS; 404 } 405 406 /** 407 Reads the requested number of blocks from the specified block device. 408 409 The function reads the requested number of blocks from the device. All the 410 blocks are read, or an error is returned. If there is no media in the device, 411 the function returns EFI_NO_MEDIA. 412 413 @param[in] PeiServices General-purpose services that are available to 414 every PEIM. 415 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance. 416 @param[in] DeviceIndex Specifies the block device to which the function wants 417 to talk. Because the driver that implements Block I/O 418 PPIs will manage multiple block devices, PPIs that 419 want to talk to a single device must specify the device 420 index that was assigned during the enumeration process. 421 This index is a number from one to NumberBlockDevices. 422 @param[in] StartLBA The starting logical block address (LBA) to read from 423 on the device 424 @param[in] BufferSize The size of the Buffer in bytes. This number must be 425 a multiple of the intrinsic block size of the device. 426 @param[out] Buffer A pointer to the destination buffer for the data. 427 The caller is responsible for the ownership of the 428 buffer. 429 430 @retval EFI_SUCCESS The data was read correctly from the device. 431 @retval EFI_DEVICE_ERROR The device reported an error while attempting 432 to perform the read operation. 433 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not 434 valid, or the buffer is not properly aligned. 435 @retval EFI_NO_MEDIA There is no media in the device. 436 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of 437 the intrinsic block size of the device. 438 439 **/ 440 EFI_STATUS 441 EFIAPI 442 SdBlockIoPeimReadBlocks2 ( 443 IN EFI_PEI_SERVICES **PeiServices, 444 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This, 445 IN UINTN DeviceIndex, 446 IN EFI_PEI_LBA StartLBA, 447 IN UINTN BufferSize, 448 OUT VOID *Buffer 449 ) 450 { 451 EFI_STATUS Status; 452 SD_PEIM_HC_PRIVATE_DATA *Private; 453 454 Status = EFI_SUCCESS; 455 Private = GET_SD_PEIM_HC_PRIVATE_DATA_FROM_THIS2 (This); 456 457 Status = SdBlockIoPeimReadBlocks ( 458 PeiServices, 459 &Private->BlkIoPpi, 460 DeviceIndex, 461 StartLBA, 462 BufferSize, 463 Buffer 464 ); 465 return Status; 466 } 467 468 /** 469 The user code starts with this function. 470 471 @param FileHandle Handle of the file being invoked. 472 @param PeiServices Describes the list of possible PEI Services. 473 474 @retval EFI_SUCCESS The driver is successfully initialized. 475 @retval Others Can't initialize the driver. 476 477 **/ 478 EFI_STATUS 479 EFIAPI 480 InitializeSdBlockIoPeim ( 481 IN EFI_PEI_FILE_HANDLE FileHandle, 482 IN CONST EFI_PEI_SERVICES **PeiServices 483 ) 484 { 485 EFI_STATUS Status; 486 SD_PEIM_HC_PRIVATE_DATA *Private; 487 EDKII_SD_MMC_HOST_CONTROLLER_PPI *SdMmcHcPpi; 488 UINT32 Index; 489 UINTN *MmioBase; 490 UINT8 BarNum; 491 UINT8 SlotNum; 492 UINT8 Controller; 493 UINT64 Capacity; 494 SD_HC_SLOT_CAP Capability; 495 SD_PEIM_HC_SLOT *Slot; 496 SD_CSD *Csd; 497 SD_CSD2 *Csd2; 498 UINT32 CSize; 499 UINT32 CSizeMul; 500 UINT32 ReadBlLen; 501 502 // 503 // Shadow this PEIM to run from memory 504 // 505 if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { 506 return EFI_SUCCESS; 507 } 508 509 // 510 // locate Sd host controller PPI 511 // 512 Status = PeiServicesLocatePpi ( 513 &gEdkiiPeiSdMmcHostControllerPpiGuid, 514 0, 515 NULL, 516 (VOID **) &SdMmcHcPpi 517 ); 518 if (EFI_ERROR (Status)) { 519 return EFI_DEVICE_ERROR; 520 } 521 522 Controller = 0; 523 MmioBase = NULL; 524 while (TRUE) { 525 Status = SdMmcHcPpi->GetSdMmcHcMmioBar (SdMmcHcPpi, Controller, &MmioBase, &BarNum); 526 // 527 // When status is error, meant no controller is found 528 // 529 if (EFI_ERROR (Status)) { 530 break; 531 } 532 533 if (BarNum == 0) { 534 Controller++; 535 continue; 536 } 537 538 Private = AllocateCopyPool (sizeof (SD_PEIM_HC_PRIVATE_DATA), &gSdHcPrivateTemplate); 539 if (Private == NULL) { 540 Status = EFI_OUT_OF_RESOURCES; 541 break; 542 } 543 Private->BlkIoPpiList.Ppi = (VOID*)&Private->BlkIoPpi; 544 Private->BlkIo2PpiList.Ppi = (VOID*)&Private->BlkIo2Ppi; 545 // 546 // Initialize the memory pool which will be used in all transactions. 547 // 548 Status = SdPeimInitMemPool (Private); 549 if (EFI_ERROR (Status)) { 550 Status = EFI_OUT_OF_RESOURCES; 551 break; 552 } 553 554 for (Index = 0; Index < BarNum; Index++) { 555 Status = SdPeimHcGetCapability (MmioBase[Index], &Capability); 556 if (EFI_ERROR (Status)) { 557 continue; 558 } 559 if (Capability.SlotType != 0x1) { 560 DEBUG ((EFI_D_INFO, "The slot at 0x%x is not embedded slot type\n", MmioBase[Index])); 561 Status = EFI_UNSUPPORTED; 562 continue; 563 } 564 565 Status = SdPeimHcReset (MmioBase[Index]); 566 if (EFI_ERROR (Status)) { 567 continue; 568 } 569 Status = SdPeimHcCardDetect (MmioBase[Index]); 570 if (EFI_ERROR (Status)) { 571 continue; 572 } 573 Status = SdPeimHcInitHost (MmioBase[Index]); 574 if (EFI_ERROR (Status)) { 575 continue; 576 } 577 578 SlotNum = Private->SlotNum; 579 Slot = &Private->Slot[SlotNum]; 580 CopyMem (Slot, &gSdHcSlotTemplate, sizeof (SD_PEIM_HC_SLOT)); 581 Slot->Private = Private; 582 Slot->SdHcBase = MmioBase[Index]; 583 CopyMem (&Slot->Capability, &Capability, sizeof (Capability)); 584 585 Status = SdPeimIdentification (Slot); 586 if (EFI_ERROR (Status)) { 587 continue; 588 } 589 590 Csd = &Slot->Csd; 591 if (Csd->CsdStructure == 0) { 592 Slot->SectorAddressing = FALSE; 593 CSize = (Csd->CSizeHigh << 2 | Csd->CSizeLow) + 1; 594 CSizeMul = (1 << (Csd->CSizeMul + 2)); 595 ReadBlLen = (1 << (Csd->ReadBlLen)); 596 Capacity = MultU64x32 (MultU64x32 ((UINT64)CSize, CSizeMul), ReadBlLen); 597 } else { 598 Slot->SectorAddressing = TRUE; 599 Csd2 = (SD_CSD2*)(VOID*)Csd; 600 CSize = (Csd2->CSizeHigh << 16 | Csd2->CSizeLow) + 1; 601 Capacity = MultU64x32 ((UINT64)CSize, SIZE_512KB); 602 } 603 604 Slot->Media.LastBlock = DivU64x32 (Capacity, Slot->Media.BlockSize) - 1; 605 606 Private->TotalBlkIoDevices++; 607 Private->SlotNum++; 608 } 609 610 Controller++; 611 if (!EFI_ERROR (Status)) { 612 PeiServicesInstallPpi (&Private->BlkIoPpiList); 613 } 614 } 615 616 return EFI_SUCCESS; 617 } 618
