1 /** @file 2 Source file for CD recovery PEIM 3 4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR> 5 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions 8 of the BSD License which accompanies this distribution. The 9 full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include "PeiCdExpress.h" 18 19 PEI_CD_EXPRESS_PRIVATE_DATA *mPrivateData = NULL; 20 21 /** 22 Installs the Device Recovery Module PPI, Initialize BlockIo Ppi 23 installation notification 24 25 @param FileHandle The file handle of the image. 26 @param PeiServices General purpose services available to every PEIM. 27 28 @retval EFI_SUCCESS The function completed successfully. 29 @retval EFI_OUT_OF_RESOURCES There is not enough system memory. 30 31 **/ 32 EFI_STATUS 33 EFIAPI 34 CdExpressPeimEntry ( 35 IN EFI_PEI_FILE_HANDLE FileHandle, 36 IN CONST EFI_PEI_SERVICES **PeiServices 37 ) 38 { 39 EFI_STATUS Status; 40 PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; 41 42 if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { 43 return EFI_SUCCESS; 44 } 45 46 PrivateData = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*PrivateData))); 47 if (PrivateData == NULL) { 48 return EFI_OUT_OF_RESOURCES; 49 } 50 51 // 52 // Initialize Private Data (to zero, as is required by subsequent operations) 53 // 54 ZeroMem (PrivateData, sizeof (*PrivateData)); 55 PrivateData->Signature = PEI_CD_EXPRESS_PRIVATE_DATA_SIGNATURE; 56 57 PrivateData->BlockBuffer = AllocatePages (EFI_SIZE_TO_PAGES (PEI_CD_BLOCK_SIZE)); 58 if (PrivateData->BlockBuffer == NULL) { 59 return EFI_OUT_OF_RESOURCES; 60 } 61 62 PrivateData->CapsuleCount = 0; 63 Status = UpdateBlocksAndVolumes (PrivateData, TRUE); 64 Status = UpdateBlocksAndVolumes (PrivateData, FALSE); 65 66 // 67 // Installs Ppi 68 // 69 PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules; 70 PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo; 71 PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule; 72 73 PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); 74 PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid; 75 PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi; 76 77 Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor); 78 if (EFI_ERROR (Status)) { 79 return EFI_OUT_OF_RESOURCES; 80 } 81 // 82 // PrivateData is allocated now, set it to the module variable 83 // 84 mPrivateData = PrivateData; 85 86 // 87 // Installs Block Io Ppi notification function 88 // 89 PrivateData->NotifyDescriptor.Flags = 90 ( 91 EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK 92 ); 93 PrivateData->NotifyDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid; 94 PrivateData->NotifyDescriptor.Notify = BlockIoNotifyEntry; 95 96 PrivateData->NotifyDescriptor2.Flags = 97 ( 98 EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | 99 EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST 100 ); 101 PrivateData->NotifyDescriptor2.Guid = &gEfiPeiVirtualBlockIo2PpiGuid; 102 PrivateData->NotifyDescriptor2.Notify = BlockIoNotifyEntry; 103 104 return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor); 105 106 } 107 108 /** 109 BlockIo installation notification function. 110 111 This function finds out all the current Block IO PPIs in the system and add them 112 into private data. 113 114 @param PeiServices Indirect reference to the PEI Services Table. 115 @param NotifyDescriptor Address of the notification descriptor data structure. 116 @param Ppi Address of the PPI that was installed. 117 118 @retval EFI_SUCCESS The function completes successfully. 119 120 **/ 121 EFI_STATUS 122 EFIAPI 123 BlockIoNotifyEntry ( 124 IN EFI_PEI_SERVICES **PeiServices, 125 IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDescriptor, 126 IN VOID *Ppi 127 ) 128 { 129 if (CompareGuid (NotifyDescriptor->Guid, &gEfiPeiVirtualBlockIo2PpiGuid)) { 130 UpdateBlocksAndVolumes (mPrivateData, TRUE); 131 } else { 132 UpdateBlocksAndVolumes (mPrivateData, FALSE); 133 } 134 135 return EFI_SUCCESS; 136 } 137 138 /** 139 Finds out all the current Block IO PPIs in the system and add them into private data. 140 141 @param PrivateData The private data structure that contains recovery module information. 142 @param BlockIo2 Boolean to show whether using BlockIo2 or BlockIo. 143 144 @retval EFI_SUCCESS The blocks and volumes are updated successfully. 145 146 **/ 147 EFI_STATUS 148 UpdateBlocksAndVolumes ( 149 IN OUT PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData, 150 IN BOOLEAN BlockIo2 151 ) 152 { 153 EFI_STATUS Status; 154 EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor; 155 UINTN BlockIoPpiInstance; 156 EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi; 157 EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi; 158 UINTN NumberBlockDevices; 159 UINTN IndexBlockDevice; 160 EFI_PEI_BLOCK_IO_MEDIA Media; 161 EFI_PEI_BLOCK_IO2_MEDIA Media2; 162 EFI_PEI_SERVICES **PeiServices; 163 164 IndexBlockDevice = 0; 165 BlockIo2Ppi = NULL; 166 BlockIoPpi = NULL; 167 // 168 // Find out all Block Io Ppi instances within the system 169 // Assuming all device Block Io Peims are dispatched already 170 // 171 for (BlockIoPpiInstance = 0; BlockIoPpiInstance < PEI_CD_EXPRESS_MAX_BLOCK_IO_PPI; BlockIoPpiInstance++) { 172 if (BlockIo2) { 173 Status = PeiServicesLocatePpi ( 174 &gEfiPeiVirtualBlockIo2PpiGuid, 175 BlockIoPpiInstance, 176 &TempPpiDescriptor, 177 (VOID **) &BlockIo2Ppi 178 ); 179 } else { 180 Status = PeiServicesLocatePpi ( 181 &gEfiPeiVirtualBlockIoPpiGuid, 182 BlockIoPpiInstance, 183 &TempPpiDescriptor, 184 (VOID **) &BlockIoPpi 185 ); 186 } 187 if (EFI_ERROR (Status)) { 188 // 189 // Done with all Block Io Ppis 190 // 191 break; 192 } 193 194 PeiServices = (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (); 195 if (BlockIo2) { 196 Status = BlockIo2Ppi->GetNumberOfBlockDevices ( 197 PeiServices, 198 BlockIo2Ppi, 199 &NumberBlockDevices 200 ); 201 } else { 202 Status = BlockIoPpi->GetNumberOfBlockDevices ( 203 PeiServices, 204 BlockIoPpi, 205 &NumberBlockDevices 206 ); 207 } 208 if (EFI_ERROR (Status) || (NumberBlockDevices == 0)) { 209 continue; 210 } 211 // 212 // Just retrieve the first block, should emulate all blocks. 213 // 214 for (IndexBlockDevice = 1; IndexBlockDevice <= NumberBlockDevices && PrivateData->CapsuleCount < PEI_CD_EXPRESS_MAX_CAPSULE_NUMBER; IndexBlockDevice ++) { 215 if (BlockIo2) { 216 Status = BlockIo2Ppi->GetBlockDeviceMediaInfo ( 217 PeiServices, 218 BlockIo2Ppi, 219 IndexBlockDevice, 220 &Media2 221 ); 222 if (EFI_ERROR (Status) || 223 !Media2.MediaPresent || 224 ((Media2.InterfaceType != MSG_ATAPI_DP) && (Media2.InterfaceType != MSG_USB_DP)) || 225 (Media2.BlockSize != PEI_CD_BLOCK_SIZE) 226 ) { 227 continue; 228 } 229 DEBUG ((EFI_D_INFO, "PeiCdExpress InterfaceType is %d\n", Media2.InterfaceType)); 230 DEBUG ((EFI_D_INFO, "PeiCdExpress MediaPresent is %d\n", Media2.MediaPresent)); 231 DEBUG ((EFI_D_INFO, "PeiCdExpress BlockSize is 0x%x\n", Media2.BlockSize)); 232 } else { 233 Status = BlockIoPpi->GetBlockDeviceMediaInfo ( 234 PeiServices, 235 BlockIoPpi, 236 IndexBlockDevice, 237 &Media 238 ); 239 if (EFI_ERROR (Status) || 240 !Media.MediaPresent || 241 ((Media.DeviceType != IdeCDROM) && (Media.DeviceType != UsbMassStorage)) || 242 (Media.BlockSize != PEI_CD_BLOCK_SIZE) 243 ) { 244 continue; 245 } 246 DEBUG ((EFI_D_INFO, "PeiCdExpress DeviceType is %d\n", Media.DeviceType)); 247 DEBUG ((EFI_D_INFO, "PeiCdExpress MediaPresent is %d\n", Media.MediaPresent)); 248 DEBUG ((EFI_D_INFO, "PeiCdExpress BlockSize is 0x%x\n", Media.BlockSize)); 249 } 250 251 DEBUG ((EFI_D_INFO, "PeiCdExpress Status is %d\n", Status)); 252 253 DEBUG ((EFI_D_INFO, "IndexBlockDevice is %d\n", IndexBlockDevice)); 254 PrivateData->CapsuleData[PrivateData->CapsuleCount].IndexBlock = IndexBlockDevice; 255 if (BlockIo2) { 256 PrivateData->CapsuleData[PrivateData->CapsuleCount].BlockIo2 = BlockIo2Ppi; 257 } else { 258 PrivateData->CapsuleData[PrivateData->CapsuleCount].BlockIo = BlockIoPpi; 259 } 260 Status = FindRecoveryCapsules (PrivateData); 261 DEBUG ((EFI_D_INFO, "Status is %d\n", Status)); 262 263 if (EFI_ERROR (Status)) { 264 continue; 265 } 266 267 PrivateData->CapsuleCount++; 268 } 269 270 } 271 272 return EFI_SUCCESS; 273 } 274 275 /** 276 Finds out the recovery capsule in the current volume. 277 278 @param PrivateData The private data structure that contains recovery module information. 279 280 @retval EFI_SUCCESS The recovery capsule is successfully found in the volume. 281 @retval EFI_NOT_FOUND The recovery capsule is not found in the volume. 282 283 **/ 284 EFI_STATUS 285 EFIAPI 286 FindRecoveryCapsules ( 287 IN OUT PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData 288 ) 289 { 290 EFI_STATUS Status; 291 UINTN Lba; 292 EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi; 293 EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi; 294 UINTN BufferSize; 295 UINT8 *Buffer; 296 UINT8 Type; 297 UINT8 *StandardID; 298 UINT32 RootDirLBA; 299 PEI_CD_EXPRESS_DIR_FILE_RECORD *RoorDirRecord; 300 UINTN VolumeSpaceSize; 301 BOOLEAN StartOfVolume; 302 UINTN OriginalLBA; 303 UINTN IndexBlockDevice; 304 305 Buffer = PrivateData->BlockBuffer; 306 BufferSize = PEI_CD_BLOCK_SIZE; 307 308 Lba = 16; 309 // 310 // The volume descriptor starts on Lba 16 311 // 312 IndexBlockDevice = PrivateData->CapsuleData[PrivateData->CapsuleCount].IndexBlock; 313 BlockIoPpi = PrivateData->CapsuleData[PrivateData->CapsuleCount].BlockIo; 314 BlockIo2Ppi = PrivateData->CapsuleData[PrivateData->CapsuleCount].BlockIo2; 315 316 VolumeSpaceSize = 0; 317 StartOfVolume = TRUE; 318 OriginalLBA = 16; 319 320 while (TRUE) { 321 SetMem (Buffer, BufferSize, 0); 322 if (BlockIo2Ppi != NULL) { 323 Status = BlockIo2Ppi->ReadBlocks ( 324 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (), 325 BlockIo2Ppi, 326 IndexBlockDevice, 327 Lba, 328 BufferSize, 329 Buffer 330 ); 331 } else { 332 Status = BlockIoPpi->ReadBlocks ( 333 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (), 334 BlockIoPpi, 335 IndexBlockDevice, 336 Lba, 337 BufferSize, 338 Buffer 339 ); 340 } 341 if (EFI_ERROR (Status)) { 342 return Status; 343 } 344 345 StandardID = (UINT8 *) (Buffer + PEI_CD_EXPRESS_STANDARD_ID_OFFSET); 346 if (!StringCmp (StandardID, (UINT8 *) PEI_CD_STANDARD_ID, PEI_CD_EXPRESS_STANDARD_ID_SIZE, TRUE)) { 347 break; 348 } 349 350 if (StartOfVolume) { 351 OriginalLBA = Lba; 352 StartOfVolume = FALSE; 353 } 354 355 Type = *(UINT8 *) (Buffer + PEI_CD_EXPRESS_VOLUME_TYPE_OFFSET); 356 if (Type == PEI_CD_EXPRESS_VOLUME_TYPE_TERMINATOR) { 357 if (VolumeSpaceSize == 0) { 358 break; 359 } else { 360 Lba = (OriginalLBA + VolumeSpaceSize); 361 VolumeSpaceSize = 0; 362 StartOfVolume = TRUE; 363 continue; 364 } 365 } 366 367 if (Type != PEI_CD_EXPRESS_VOLUME_TYPE_PRIMARY) { 368 Lba++; 369 continue; 370 } 371 372 VolumeSpaceSize = *(UINT32 *) (Buffer + PEI_CD_EXPRESS_VOLUME_SPACE_OFFSET); 373 374 RoorDirRecord = (PEI_CD_EXPRESS_DIR_FILE_RECORD *) (Buffer + PEI_CD_EXPRESS_ROOT_DIR_RECORD_OFFSET); 375 RootDirLBA = RoorDirRecord->LocationOfExtent[0]; 376 377 Status = RetrieveCapsuleFileFromRoot (PrivateData, BlockIoPpi, BlockIo2Ppi, IndexBlockDevice, RootDirLBA); 378 if (!EFI_ERROR (Status)) { 379 // 380 // Just look for the first primary descriptor 381 // 382 return EFI_SUCCESS; 383 } 384 385 Lba++; 386 } 387 388 return EFI_NOT_FOUND; 389 } 390 391 /** 392 Retrieves the recovery capsule in root directory of the current volume. 393 394 @param PrivateData The private data structure that contains recovery module information. 395 @param BlockIoPpi The Block IO PPI used to access the volume. 396 @param BlockIo2Ppi The Block IO 2 PPI used to access the volume. 397 @param IndexBlockDevice The index of current block device. 398 @param Lba The starting logic block address to retrieve capsule. 399 400 @retval EFI_SUCCESS The recovery capsule is successfully found in the volume. 401 @retval EFI_NOT_FOUND The recovery capsule is not found in the volume. 402 @retval Others 403 404 **/ 405 EFI_STATUS 406 EFIAPI 407 RetrieveCapsuleFileFromRoot ( 408 IN OUT PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData, 409 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi, 410 IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi, 411 IN UINTN IndexBlockDevice, 412 IN UINT32 Lba 413 ) 414 { 415 EFI_STATUS Status; 416 UINTN BufferSize; 417 UINT8 *Buffer; 418 PEI_CD_EXPRESS_DIR_FILE_RECORD *FileRecord; 419 UINTN Index; 420 421 Buffer = PrivateData->BlockBuffer; 422 BufferSize = PEI_CD_BLOCK_SIZE; 423 424 SetMem (Buffer, BufferSize, 0); 425 426 if (BlockIo2Ppi != NULL) { 427 Status = BlockIo2Ppi->ReadBlocks ( 428 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (), 429 BlockIo2Ppi, 430 IndexBlockDevice, 431 Lba, 432 BufferSize, 433 Buffer 434 ); 435 } else { 436 Status = BlockIoPpi->ReadBlocks ( 437 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (), 438 BlockIoPpi, 439 IndexBlockDevice, 440 Lba, 441 BufferSize, 442 Buffer 443 ); 444 } 445 if (EFI_ERROR (Status)) { 446 return Status; 447 } 448 449 while (1) { 450 FileRecord = (PEI_CD_EXPRESS_DIR_FILE_RECORD *) Buffer; 451 452 if (FileRecord->Length == 0) { 453 break; 454 } 455 // 456 // Not intend to check other flag now 457 // 458 if ((FileRecord->Flag & PEI_CD_EXPRESS_DIR_FILE_REC_FLAG_ISDIR) != 0) { 459 Buffer += FileRecord->Length; 460 continue; 461 } 462 463 for (Index = 0; Index < FileRecord->FileIDLength; Index++) { 464 if (FileRecord->FileID[Index] == ';') { 465 break; 466 } 467 } 468 469 if (Index != (sizeof (PEI_RECOVERY_FILE_NAME) - 1)) { 470 Buffer += FileRecord->Length; 471 continue; 472 } 473 474 if (!StringCmp (FileRecord->FileID, (UINT8 *) PEI_RECOVERY_FILE_NAME, sizeof (PEI_RECOVERY_FILE_NAME) - 1, FALSE)) { 475 Buffer += FileRecord->Length; 476 continue; 477 } 478 479 PrivateData->CapsuleData[PrivateData->CapsuleCount].CapsuleStartLBA = FileRecord->LocationOfExtent[0]; 480 PrivateData->CapsuleData[PrivateData->CapsuleCount].CapsuleSize = 481 ( 482 FileRecord->DataLength[0] / 483 PEI_CD_BLOCK_SIZE + 484 1 485 ) * 486 PEI_CD_BLOCK_SIZE; 487 488 return EFI_SUCCESS; 489 } 490 491 return EFI_NOT_FOUND; 492 } 493 494 /** 495 Returns the number of DXE capsules residing on the device. 496 497 This function searches for DXE capsules from the associated device and returns 498 the number and maximum size in bytes of the capsules discovered. Entry 1 is 499 assumed to be the highest load priority and entry N is assumed to be the lowest 500 priority. 501 502 @param[in] PeiServices General-purpose services that are available 503 to every PEIM 504 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI 505 instance. 506 @param[out] NumberRecoveryCapsules Pointer to a caller-allocated UINTN. On 507 output, *NumberRecoveryCapsules contains 508 the number of recovery capsule images 509 available for retrieval from this PEIM 510 instance. 511 512 @retval EFI_SUCCESS One or more capsules were discovered. 513 @retval EFI_DEVICE_ERROR A device error occurred. 514 @retval EFI_NOT_FOUND A recovery DXE capsule cannot be found. 515 516 **/ 517 EFI_STATUS 518 EFIAPI 519 GetNumberRecoveryCapsules ( 520 IN EFI_PEI_SERVICES **PeiServices, 521 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, 522 OUT UINTN *NumberRecoveryCapsules 523 ) 524 { 525 PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; 526 527 PrivateData = PEI_CD_EXPRESS_PRIVATE_DATA_FROM_THIS (This); 528 UpdateBlocksAndVolumes (PrivateData, TRUE); 529 UpdateBlocksAndVolumes (PrivateData, FALSE); 530 *NumberRecoveryCapsules = PrivateData->CapsuleCount; 531 532 if (*NumberRecoveryCapsules == 0) { 533 return EFI_NOT_FOUND; 534 } 535 536 return EFI_SUCCESS; 537 } 538 539 /** 540 Returns the size and type of the requested recovery capsule. 541 542 This function gets the size and type of the capsule specified by CapsuleInstance. 543 544 @param[in] PeiServices General-purpose services that are available to every PEIM 545 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI 546 instance. 547 @param[in] CapsuleInstance Specifies for which capsule instance to retrieve 548 the information. This parameter must be between 549 one and the value returned by GetNumberRecoveryCapsules() 550 in NumberRecoveryCapsules. 551 @param[out] Size A pointer to a caller-allocated UINTN in which 552 the size of the requested recovery module is 553 returned. 554 @param[out] CapsuleType A pointer to a caller-allocated EFI_GUID in which 555 the type of the requested recovery capsule is 556 returned. The semantic meaning of the value 557 returned is defined by the implementation. 558 559 @retval EFI_SUCCESS One or more capsules were discovered. 560 @retval EFI_DEVICE_ERROR A device error occurred. 561 @retval EFI_NOT_FOUND A recovery DXE capsule cannot be found. 562 563 **/ 564 EFI_STATUS 565 EFIAPI 566 GetRecoveryCapsuleInfo ( 567 IN EFI_PEI_SERVICES **PeiServices, 568 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, 569 IN UINTN CapsuleInstance, 570 OUT UINTN *Size, 571 OUT EFI_GUID *CapsuleType 572 ) 573 { 574 PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; 575 UINTN NumberRecoveryCapsules; 576 EFI_STATUS Status; 577 578 Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules); 579 580 if (EFI_ERROR (Status)) { 581 return Status; 582 } 583 584 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport)) { 585 CapsuleInstance = CapsuleInstance + 1; 586 } 587 588 if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) { 589 return EFI_NOT_FOUND; 590 } 591 592 PrivateData = PEI_CD_EXPRESS_PRIVATE_DATA_FROM_THIS (This); 593 594 *Size = PrivateData->CapsuleData[CapsuleInstance - 1].CapsuleSize; 595 CopyMem ( 596 CapsuleType, 597 &gRecoveryOnDataCdGuid, 598 sizeof (EFI_GUID) 599 ); 600 601 return EFI_SUCCESS; 602 } 603 604 /** 605 Loads a DXE capsule from some media into memory. 606 607 This function, by whatever mechanism, retrieves a DXE capsule from some device 608 and loads it into memory. Note that the published interface is device neutral. 609 610 @param[in] PeiServices General-purpose services that are available 611 to every PEIM 612 @param[in] This Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI 613 instance. 614 @param[in] CapsuleInstance Specifies which capsule instance to retrieve. 615 @param[out] Buffer Specifies a caller-allocated buffer in which 616 the requested recovery capsule will be returned. 617 618 @retval EFI_SUCCESS The capsule was loaded correctly. 619 @retval EFI_DEVICE_ERROR A device error occurred. 620 @retval EFI_NOT_FOUND A requested recovery DXE capsule cannot be found. 621 622 **/ 623 EFI_STATUS 624 EFIAPI 625 LoadRecoveryCapsule ( 626 IN EFI_PEI_SERVICES **PeiServices, 627 IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, 628 IN UINTN CapsuleInstance, 629 OUT VOID *Buffer 630 ) 631 { 632 EFI_STATUS Status; 633 PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; 634 EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi; 635 EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi; 636 UINTN NumberRecoveryCapsules; 637 638 Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules); 639 640 if (EFI_ERROR (Status)) { 641 return Status; 642 } 643 644 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport)) { 645 CapsuleInstance = CapsuleInstance + 1; 646 } 647 648 if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) { 649 return EFI_NOT_FOUND; 650 } 651 652 PrivateData = PEI_CD_EXPRESS_PRIVATE_DATA_FROM_THIS (This); 653 BlockIoPpi = PrivateData->CapsuleData[CapsuleInstance - 1].BlockIo; 654 BlockIo2Ppi = PrivateData->CapsuleData[CapsuleInstance - 1].BlockIo2; 655 656 if (BlockIo2Ppi != NULL) { 657 Status = BlockIo2Ppi->ReadBlocks ( 658 PeiServices, 659 BlockIo2Ppi, 660 PrivateData->CapsuleData[CapsuleInstance - 1].IndexBlock, 661 PrivateData->CapsuleData[CapsuleInstance - 1].CapsuleStartLBA, 662 PrivateData->CapsuleData[CapsuleInstance - 1].CapsuleSize, 663 Buffer 664 ); 665 } else { 666 Status = BlockIoPpi->ReadBlocks ( 667 PeiServices, 668 BlockIoPpi, 669 PrivateData->CapsuleData[CapsuleInstance - 1].IndexBlock, 670 PrivateData->CapsuleData[CapsuleInstance - 1].CapsuleStartLBA, 671 PrivateData->CapsuleData[CapsuleInstance - 1].CapsuleSize, 672 Buffer 673 ); 674 } 675 return Status; 676 } 677 678 /** 679 This function compares two ASCII strings in case sensitive/insensitive way. 680 681 @param Source1 The first string. 682 @param Source2 The second string. 683 @param Size The maximum comparison length. 684 @param CaseSensitive Flag to indicate whether the comparison is case sensitive. 685 686 @retval TRUE The two strings are the same. 687 @retval FALSE The two string are not the same. 688 689 **/ 690 BOOLEAN 691 StringCmp ( 692 IN UINT8 *Source1, 693 IN UINT8 *Source2, 694 IN UINTN Size, 695 IN BOOLEAN CaseSensitive 696 ) 697 { 698 UINTN Index; 699 UINT8 Dif; 700 701 for (Index = 0; Index < Size; Index++) { 702 if (Source1[Index] == Source2[Index]) { 703 continue; 704 } 705 706 if (!CaseSensitive) { 707 Dif = (UINT8) ((Source1[Index] > Source2[Index]) ? (Source1[Index] - Source2[Index]) : (Source2[Index] - Source1[Index])); 708 if (Dif == ('a' - 'A')) { 709 continue; 710 } 711 } 712 713 return FALSE; 714 } 715 716 return TRUE; 717 } 718
