/** The Entry point of the CPU I/O PEIM This function is the Entry point of the CPU I/O PEIM which installs CpuIoPpi. @param[in] FileHandle Pointer to image file handle. @param[in] PeiServices Pointer to PEI Services Table @retval EFI_SUCCESS CPU I/O PPI successfully installed **/ EFI_STATUS EFIAPI CpuIoInitialize ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; // // Register so it will be automatically shadowed to memory // Status = PeiServicesRegisterForShadow (FileHandle); // // Make CpuIo pointer in PeiService table point to gCpuIoPpi // (*((EFI_PEI_SERVICES **)PeiServices))->CpuIo = &gCpuIoPpi; if (Status == EFI_ALREADY_STARTED) { // // Shadow completed and running from memory // DEBUG ((EFI_D_INFO, "CpuIO PPI has been loaded into memory. Reinstalled PPI=0x%x\n", &gCpuIoPpi)); } else { Status = PeiServicesInstallPpi (&gPpiList); ASSERT_EFI_ERROR (Status); } return EFI_SUCCESS; }
/** Entry point of DXE IPL PEIM. This function installs DXE IPL PPI and Decompress PPI. It also reloads itself to memory on non-S3 resume boot path. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCESS The entry point of DXE IPL PEIM executes successfully. @retval Others Some error occurs during the execution of this function. **/ EFI_STATUS EFIAPI PeimInitializeDxeIpl ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; EFI_GUID *ExtractHandlerGuidTable; UINTN ExtractHandlerNumber; EFI_PEI_PPI_DESCRIPTOR *GuidPpi; BootMode = GetBootModeHob (); if (BootMode != BOOT_ON_S3_RESUME) { Status = PeiServicesRegisterForShadow (FileHandle); if (Status == EFI_SUCCESS) { // // EFI_SUCESS means it is the first time to call register for shadow. // return Status; } // // Ensure that DXE IPL is shadowed to permanent memory. // ASSERT (Status == EFI_ALREADY_STARTED); // // Get custom extract guided section method guid list // ExtractHandlerNumber = ExtractGuidedSectionGetGuidList (&ExtractHandlerGuidTable); // // Install custom extraction guid PPI // if (ExtractHandlerNumber > 0) { GuidPpi = (EFI_PEI_PPI_DESCRIPTOR *) AllocatePool (ExtractHandlerNumber * sizeof (EFI_PEI_PPI_DESCRIPTOR)); ASSERT (GuidPpi != NULL); while (ExtractHandlerNumber-- > 0) { GuidPpi->Flags = EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST; GuidPpi->Ppi = (VOID *) &mCustomGuidedSectionExtractionPpi; GuidPpi->Guid = &ExtractHandlerGuidTable[ExtractHandlerNumber]; Status = PeiServicesInstallPpi (GuidPpi++); ASSERT_EFI_ERROR(Status); } } } // // Install DxeIpl and Decompress PPIs. // Status = PeiServicesInstallPpi (mPpiList); ASSERT_EFI_ERROR(Status); return Status; }
/** Initializes the Usb Bot. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Usb bot driver is successfully initialized. @retval EFI_OUT_OF_RESOURCES Can't initialize the driver. **/ EFI_STATUS EFIAPI PeimInitializeUsbBot ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; UINTN UsbIoPpiInstance; EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor; PEI_USB_IO_PPI *UsbIoPpi; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } // // locate all usb io PPIs // for (UsbIoPpiInstance = 0; UsbIoPpiInstance < PEI_FAT_MAX_USB_IO_PPI; UsbIoPpiInstance++) { Status = PeiServicesLocatePpi ( &gPeiUsbIoPpiGuid, UsbIoPpiInstance, &TempPpiDescriptor, (VOID **) &UsbIoPpi ); if (EFI_ERROR (Status)) { break; } } // // Register a notify function // return PeiServicesNotifyPpi (&mNotifyList); }
/** Installs the Device Recovery Module PPI, Initialize BlockIo Ppi installation notification @param FileHandle The file handle of the image. @param PeiServices General purpose services available to every PEIM. @retval EFI_SUCCESS The function completed successfully. @retval EFI_OUT_OF_RESOURCES There is not enough system memory. **/ EFI_STATUS EFIAPI CdExpressPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } PrivateData = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*PrivateData))); if (PrivateData == NULL) { return EFI_OUT_OF_RESOURCES; } // // Initialize Private Data (to zero, as is required by subsequent operations) // ZeroMem (PrivateData, sizeof (*PrivateData)); PrivateData->Signature = PEI_CD_EXPRESS_PRIVATE_DATA_SIGNATURE; PrivateData->BlockBuffer = AllocatePages (EFI_SIZE_TO_PAGES (PEI_CD_BLOCK_SIZE)); if (PrivateData->BlockBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } PrivateData->CapsuleCount = 0; Status = UpdateBlocksAndVolumes (PrivateData, TRUE); Status = UpdateBlocksAndVolumes (PrivateData, FALSE); // // Installs Ppi // PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules; PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo; PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule; PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid; PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi; Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } // // PrivateData is allocated now, set it to the module variable // mPrivateData = PrivateData; // // Installs Block Io Ppi notification function // PrivateData->NotifyDescriptor.Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK ); PrivateData->NotifyDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid; PrivateData->NotifyDescriptor.Notify = BlockIoNotifyEntry; PrivateData->NotifyDescriptor2.Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST ); PrivateData->NotifyDescriptor2.Guid = &gEfiPeiVirtualBlockIo2PpiGuid; PrivateData->NotifyDescriptor2.Notify = BlockIoNotifyEntry; return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor); }
/** @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS PPI successfully installed. **/ EFI_STATUS EFIAPI EhcPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { PEI_USB_CONTROLLER_PPI *ChipSetUsbControllerPpi; EFI_STATUS Status; UINT8 Index; UINTN ControllerType; UINTN BaseAddress; UINTN MemPages; PEI_USB2_HC_DEV *EhcDev; EFI_PHYSICAL_ADDRESS TempPtr; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } Status = PeiServicesLocatePpi ( &gPeiUsbControllerPpiGuid, 0, NULL, (VOID **) &ChipSetUsbControllerPpi ); if (EFI_ERROR (Status)) { return EFI_UNSUPPORTED; } Index = 0; while (TRUE) { Status = ChipSetUsbControllerPpi->GetUsbController ( (EFI_PEI_SERVICES **) PeiServices, ChipSetUsbControllerPpi, Index, &ControllerType, &BaseAddress ); // // When status is error, meant no controller is found // if (EFI_ERROR (Status)) { break; } // // This PEIM is for UHC type controller. // if (ControllerType != PEI_EHCI_CONTROLLER) { Index++; continue; } MemPages = sizeof (PEI_USB2_HC_DEV) / PAGESIZE + 1; Status = PeiServicesAllocatePages ( EfiBootServicesCode, MemPages, &TempPtr ); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } ZeroMem((VOID *)(UINTN)TempPtr, MemPages*PAGESIZE); EhcDev = (PEI_USB2_HC_DEV *) ((UINTN) TempPtr); EhcDev->Signature = USB2_HC_DEV_SIGNATURE; EhcDev->UsbHostControllerBaseAddress = (UINT32) BaseAddress; EhcDev->HcStructParams = EhcReadCapRegister (EhcDev, EHC_HCSPARAMS_OFFSET); EhcDev->HcCapParams = EhcReadCapRegister (EhcDev, EHC_HCCPARAMS_OFFSET); EhcDev->CapLen = EhcReadCapRegister (EhcDev, EHC_CAPLENGTH_OFFSET) & 0x0FF; // // Initialize Uhc's hardware // Status = InitializeUsbHC (EhcDev); if (EFI_ERROR (Status)) { return Status; } EhcDev->Usb2HostControllerPpi.ControlTransfer = EhcControlTransfer; EhcDev->Usb2HostControllerPpi.BulkTransfer = EhcBulkTransfer; EhcDev->Usb2HostControllerPpi.GetRootHubPortNumber = EhcGetRootHubPortNumber; EhcDev->Usb2HostControllerPpi.GetRootHubPortStatus = EhcGetRootHubPortStatus; EhcDev->Usb2HostControllerPpi.SetRootHubPortFeature = EhcSetRootHubPortFeature; EhcDev->Usb2HostControllerPpi.ClearRootHubPortFeature = EhcClearRootHubPortFeature; EhcDev->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); EhcDev->PpiDescriptor.Guid = &gPeiUsb2HostControllerPpiGuid; EhcDev->PpiDescriptor.Ppi = &EhcDev->Usb2HostControllerPpi; Status = PeiServicesInstallPpi (&EhcDev->PpiDescriptor); if (EFI_ERROR (Status)) { Index++; continue; } Index++; } return EFI_SUCCESS; }
/** @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS PPI successfully installed. **/ EFI_STATUS OhcPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { PEI_USB_CONTROLLER_PPI *ChipSetUsbControllerPpi; EFI_STATUS Status; UINT8 Index; UINTN ControllerType; UINTN BaseAddress; UINTN MemPages; USB_OHCI_HC_DEV *Ohc; EFI_PHYSICAL_ADDRESS TempPtr; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } Status = PeiServicesLocatePpi ( &gPeiUsbControllerPpiGuid, 0, NULL, (VOID **) &ChipSetUsbControllerPpi ); if (EFI_ERROR (Status)) { return EFI_UNSUPPORTED; } Index = 0; while (TRUE) { Status = ChipSetUsbControllerPpi->GetUsbController ( (EFI_PEI_SERVICES **) PeiServices, ChipSetUsbControllerPpi, Index, &ControllerType, &BaseAddress ); // // When status is error, meant no controller is found // if (EFI_ERROR (Status)) { break; } // // This PEIM is for OHC type controller. // if (ControllerType != PEI_OHCI_CONTROLLER) { Index++; continue; } MemPages = sizeof (USB_OHCI_HC_DEV) / PAGESIZE + 1; Status = PeiServicesAllocatePages ( EfiBootServicesCode, MemPages, &TempPtr ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_INFO, "OhcPeimEntry: Fail to allocate buffer for the %dth OHCI ControllerPpi\n", Index)); return EFI_OUT_OF_RESOURCES; } ZeroMem((VOID *)(UINTN)TempPtr, MemPages*PAGESIZE); Ohc = (USB_OHCI_HC_DEV *) ((UINTN) TempPtr); Ohc->Signature = USB_OHCI_HC_DEV_SIGNATURE; Ohc->UsbHostControllerBaseAddress = (UINT32) BaseAddress; // // Initialize Uhc's hardware // Status = InitializeUsbHC ( (EFI_PEI_SERVICES **)PeiServices, Ohc, EFI_USB_HC_RESET_GLOBAL ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_INFO, "OhcPeimEntry: Fail to init %dth OHCI ControllerPpi\n", Index)); return Status; } // // Control & Bulk transfer services are accessed via their Redirect // routine versions on Quark so that USB DMA transfers do not cause an // IMR violation. // Ohc->UsbHostControllerPpi.ControlTransfer = RedirectOhciControlTransfer; Ohc->UsbHostControllerPpi.BulkTransfer = RedirectOhciBulkTransfer; Ohc->UsbHostControllerPpi.GetRootHubPortNumber = OhciGetRootHubNumOfPorts; Ohc->UsbHostControllerPpi.GetRootHubPortStatus = OhciGetRootHubPortStatus; Ohc->UsbHostControllerPpi.SetRootHubPortFeature = OhciSetRootHubPortFeature; Ohc->UsbHostControllerPpi.ClearRootHubPortFeature = OhciClearRootHubPortFeature; Ohc->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); Ohc->PpiDescriptor.Guid = &gPeiUsbHostControllerPpiGuid; Ohc->PpiDescriptor.Ppi = &Ohc->UsbHostControllerPpi; Status = PeiServicesInstallPpi (&Ohc->PpiDescriptor); if (EFI_ERROR (Status)) { Index++; continue; } Index++; } return EFI_SUCCESS; }
/** Entry point of DXE IPL PEIM. This function installs DXE IPL PPI. It also reloads itself to memory on non-S3 resume boot path. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCESS The entry point of DXE IPL PEIM executes successfully. @retval Others Some error occurs during the execution of this function. **/ EFI_STATUS EFIAPI PeimInitializeDxeIpl ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; VOID *Dummy; BootMode = GetBootModeHob (); if (BootMode != BOOT_ON_S3_RESUME) { Status = PeiServicesRegisterForShadow (FileHandle); if (Status == EFI_SUCCESS) { // // EFI_SUCESS means it is the first time to call register for shadow. // return Status; } // // Ensure that DXE IPL is shadowed to permanent memory. // ASSERT (Status == EFI_ALREADY_STARTED); // // DXE core load requires permanent memory. // Status = PeiServicesLocatePpi ( &gEfiPeiMemoryDiscoveredPpiGuid, 0, NULL, (VOID **) &Dummy ); ASSERT_EFI_ERROR (Status); if (EFI_ERROR (Status)) { return Status; } // // Now the permanent memory exists, install the PPIs for decompression // and section extraction. // Status = InstallIplPermanentMemoryPpis (NULL, NULL, NULL); ASSERT_EFI_ERROR (Status); } else { // // Install memory discovered PPI notification to install PPIs for // decompression and section extraction. // Status = PeiServicesNotifyPpi (&mMemoryDiscoveredNotifyList); ASSERT_EFI_ERROR (Status); } // // Install DxeIpl PPI. // Status = PeiServicesInstallPpi (&mDxeIplPpiList); ASSERT_EFI_ERROR(Status); return Status; }
/** Installs the Device Recovery Module PPI, Initialize BlockIo Ppi installation notification @param FileHandle Handle of the file being invoked. Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile(). @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS The entry point was executed successfully. @retval EFI_OUT_OF_RESOURCES There is no enough memory to complete the operations. **/ EFI_STATUS EFIAPI FatPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_PHYSICAL_ADDRESS Address; PEI_FAT_PRIVATE_DATA *PrivateData; Status = PeiServicesRegisterForShadow (FileHandle); if (!EFI_ERROR (Status)) { return Status; } Status = PeiServicesAllocatePages ( EfiBootServicesCode, (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMMORY_PAGE_SIZE + 1, &Address ); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } PrivateData = (PEI_FAT_PRIVATE_DATA *) (UINTN) Address; // // Initialize Private Data (to zero, as is required by subsequent operations) // ZeroMem ((UINT8 *) PrivateData, sizeof (PEI_FAT_PRIVATE_DATA)); PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE; // // Installs Ppi // PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules; PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo; PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule; PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid; PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi; Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } // // Other initializations // PrivateData->BlockDeviceCount = 0; UpdateBlocksAndVolumes (PrivateData, TRUE); UpdateBlocksAndVolumes (PrivateData, FALSE); // // PrivateData is allocated now, set it to the module variable // mPrivateData = PrivateData; // // Installs Block Io Ppi notification function // PrivateData->NotifyDescriptor[0].Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK ); PrivateData->NotifyDescriptor[0].Guid = &gEfiPeiVirtualBlockIoPpiGuid; PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry; PrivateData->NotifyDescriptor[1].Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST ); PrivateData->NotifyDescriptor[1].Guid = &gEfiPeiVirtualBlockIo2PpiGuid; PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry; return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]); }
/** The user code starts with this function. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS The driver is successfully initialized. @retval Others Can't initialize the driver. **/ EFI_STATUS EFIAPI InitializeUfsBlockIoPeim ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; UFS_PEIM_HC_PRIVATE_DATA *Private; EDKII_UFS_HOST_CONTROLLER_PPI *UfsHcPpi; UINT32 Index; UFS_CONFIG_DESC Config; UINTN MmioBase; UINT8 Controller; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } // // locate ufs host controller PPI // Status = PeiServicesLocatePpi ( &gEdkiiPeiUfsHostControllerPpiGuid, 0, NULL, (VOID **) &UfsHcPpi ); if (EFI_ERROR (Status)) { return EFI_DEVICE_ERROR; } Controller = 0; MmioBase = 0; while (TRUE) { Status = UfsHcPpi->GetUfsHcMmioBar (UfsHcPpi, Controller, &MmioBase); // // When status is error, meant no controller is found // if (EFI_ERROR (Status)) { break; } Private = AllocateCopyPool (sizeof (UFS_PEIM_HC_PRIVATE_DATA), &gUfsHcPeimTemplate); if (Private == NULL) { Status = EFI_OUT_OF_RESOURCES; break; } Private->BlkIoPpiList.Ppi = &Private->BlkIoPpi; Private->BlkIo2PpiList.Ppi = &Private->BlkIo2Ppi; Private->UfsHcBase = MmioBase; // // Initialize the memory pool which will be used in all transactions. // Status = UfsPeimInitMemPool (Private); if (EFI_ERROR (Status)) { Status = EFI_OUT_OF_RESOURCES; break; } // // Initialize UFS Host Controller H/W. // Status = UfsControllerInit (Private); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "UfsDevicePei: Host Controller Initialization Error, Status = %r\n", Status)); Controller++; continue; } // // UFS 2.0 spec Section 13.1.3.3: // At the end of the UFS Interconnect Layer initialization on both host and device side, // the host shall send a NOP OUT UPIU to verify that the device UTP Layer is ready. // Status = UfsExecNopCmds (Private); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Ufs Sending NOP IN command Error, Status = %r\n", Status)); Controller++; continue; } // // The host enables the device initialization completion by setting fDeviceInit flag. // Status = UfsSetFlag (Private, UfsFlagDevInit); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Ufs Set fDeviceInit Flag Error, Status = %r\n", Status)); Controller++; continue; } // // Get Ufs Device's Lun Info by reading Configuration Descriptor. // Status = UfsRwDeviceDesc (Private, TRUE, UfsConfigDesc, 0, 0, &Config, sizeof (UFS_CONFIG_DESC)); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Ufs Get Configuration Descriptor Error, Status = %r\n", Status)); Controller++; continue; } for (Index = 0; Index < UFS_PEIM_MAX_LUNS; Index++) { if (Config.UnitDescConfParams[Index].LunEn != 0) { Private->Luns.BitMask |= (BIT0 << Index); DEBUG ((EFI_D_INFO, "Ufs %d Lun %d is enabled\n", Controller, Index)); } } Status = PeiServicesInstallPpi (&Private->BlkIoPpiList); Controller++; } return EFI_SUCCESS; }
/** The entrypoint of the module, it will enumerate all HCs. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Usb initialization is done successfully. @retval EFI_OUT_OF_RESOURCES Can't allocate memory resource. @retval EFI_UNSUPPORTED Can't find required PPI. **/ EFI_STATUS EFIAPI PeimInitializeUsb ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; UINTN Index; PEI_USB_HOST_CONTROLLER_PPI *UsbHcPpi; PEI_USB2_HOST_CONTROLLER_PPI *Usb2HcPpi; if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } // // gPeiUsbHostControllerPpiGuid and gPeiUsb2HostControllerPpiGuid should not // be produced at the same time // Index = 0; while (TRUE) { // // Get UsbHcPpi at first. // Status = PeiServicesLocatePpi ( &gPeiUsbHostControllerPpiGuid, Index, NULL, (VOID **) &UsbHcPpi ); if (EFI_ERROR (Status)) { // // No more host controller, break out // break; } PeiUsbEnumeration ((EFI_PEI_SERVICES **) PeiServices, UsbHcPpi, NULL); Index++; } if (Index == 0) { // // Then try to get Usb2HcPpi. // while (TRUE) { Status = PeiServicesLocatePpi ( &gPeiUsb2HostControllerPpiGuid, Index, NULL, (VOID **) &Usb2HcPpi ); if (EFI_ERROR (Status)) { // // No more host controller, break out // break; } PeiUsbEnumeration ((EFI_PEI_SERVICES **) PeiServices, NULL, Usb2HcPpi); Index++; } } if (Index == 0) { return EFI_UNSUPPORTED; } return EFI_SUCCESS; }
/** The user code starts with this function. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS The driver is successfully initialized. @retval Others Can't initialize the driver. **/ EFI_STATUS EFIAPI InitializeSdMmcHcPeim ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_BOOT_MODE BootMode; EFI_STATUS Status; UINT16 Bus; UINT16 Device; UINT16 Function; UINT32 Size; UINT64 MmioSize; UINT8 SubClass; UINT8 BaseClass; UINT8 SlotInfo; UINT8 SlotNum; UINT8 FirstBar; UINT8 Index; UINT8 Slot; UINT32 BarAddr; SD_MMC_HC_PEI_PRIVATE_DATA *Private; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } Status = PeiServicesGetBootMode (&BootMode); /// /// We do not expose this in S3 boot path, because it is only for recovery. /// if (BootMode == BOOT_ON_S3_RESUME) { return EFI_SUCCESS; } Private = (SD_MMC_HC_PEI_PRIVATE_DATA *) AllocateZeroPool (sizeof (SD_MMC_HC_PEI_PRIVATE_DATA)); if (Private == NULL) { DEBUG ((EFI_D_ERROR, "Failed to allocate memory for SD_MMC_HC_PEI_PRIVATE_DATA! \n")); return EFI_OUT_OF_RESOURCES; } Private->Signature = SD_MMC_HC_PEI_SIGNATURE; Private->SdMmcHostControllerPpi = mSdMmcHostControllerPpi; Private->PpiList = mPpiList; Private->PpiList.Ppi = &Private->SdMmcHostControllerPpi; BarAddr = PcdGet32 (PcdSdMmcPciHostControllerMmioBase); for (Bus = 0; Bus < 256; Bus++) { for (Device = 0; Device < 32; Device++) { for (Function = 0; Function < 8; Function++) { SubClass = PciRead8 (PCI_LIB_ADDRESS (Bus, Device, Function, 0x0A)); BaseClass = PciRead8 (PCI_LIB_ADDRESS (Bus, Device, Function, 0x0B)); if ((SubClass == PCI_SUBCLASS_SD_HOST_CONTROLLER) && (BaseClass == PCI_CLASS_SYSTEM_PERIPHERAL)) { // // Get the SD/MMC Pci host controller's Slot Info. // SlotInfo = PciRead8 (PCI_LIB_ADDRESS (Bus, Device, Function, SD_MMC_HC_PEI_SLOT_OFFSET)); FirstBar = (*(SD_MMC_HC_PEI_SLOT_INFO*)&SlotInfo).FirstBar; SlotNum = (*(SD_MMC_HC_PEI_SLOT_INFO*)&SlotInfo).SlotNum + 1; ASSERT ((FirstBar + SlotNum) < MAX_SD_MMC_SLOTS); for (Index = 0, Slot = FirstBar; Slot < (FirstBar + SlotNum); Index++, Slot++) { // // Get the SD/MMC Pci host controller's MMIO region size. // PciAnd16 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_COMMAND_OFFSET), (UINT16)~(EFI_PCI_COMMAND_BUS_MASTER | EFI_PCI_COMMAND_MEMORY_SPACE)); PciWrite32 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4 * Slot), 0xFFFFFFFF); Size = PciRead32 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4 * Slot)); switch (Size & 0x07) { case 0x0: // // Memory space: anywhere in 32 bit address space // MmioSize = (~(Size & 0xFFFFFFF0)) + 1; break; case 0x4: // // Memory space: anywhere in 64 bit address space // MmioSize = Size & 0xFFFFFFF0; PciWrite32 (PCI_LIB_ADDRESS(Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4), 0xFFFFFFFF); Size = PciRead32 (PCI_LIB_ADDRESS(Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4)); // // Fix the length to support some spefic 64 bit BAR // Size |= ((UINT32)(-1) << HighBitSet32 (Size)); // // Calculate the size of 64bit bar // MmioSize |= LShiftU64 ((UINT64) Size, 32); MmioSize = (~(MmioSize)) + 1; // // Clean the high 32bits of this 64bit BAR to 0 as we only allow a 32bit BAR. // PciWrite32 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4 * Slot + 4), 0); break; default: // // Unknown BAR type // ASSERT (FALSE); continue; }; // // Assign resource to the SdMmc Pci host controller's MMIO BAR. // Enable the SdMmc Pci host controller by setting BME and MSE bits of PCI_CMD register. // PciWrite32 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_BASE_ADDRESSREG_OFFSET + 4 * Slot), BarAddr); PciOr16 (PCI_LIB_ADDRESS (Bus, Device, Function, PCI_COMMAND_OFFSET), (EFI_PCI_COMMAND_BUS_MASTER | EFI_PCI_COMMAND_MEMORY_SPACE)); // // Record the allocated Mmio base address. // Private->MmioBar[Private->TotalSdMmcHcs].SlotNum++; Private->MmioBar[Private->TotalSdMmcHcs].MmioBarAddr[Index] = BarAddr; BarAddr += (UINT32)MmioSize; } Private->TotalSdMmcHcs++; ASSERT (Private->TotalSdMmcHcs < MAX_SD_MMC_HCS); } } } } /// /// Install SdMmc Host Controller PPI /// Status = PeiServicesInstallPpi (&Private->PpiList); ASSERT_EFI_ERROR (Status); return Status; }