/** Switch the clock frequency to the specified value. Refer to EMMC Electrical Standard Spec 5.1 Section 6.6 and SD Host Controller Simplified Spec 3.0 Figure 3-3 for details. @param[in] PciIo A pointer to the EFI_PCI_IO_PROTOCOL instance. @param[in] PassThru A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance. @param[in] Slot The slot number of the SD card to send the command to. @param[in] Rca The relative device address to be assigned. @param[in] HsTiming The value to be written to HS_TIMING field of EXT_CSD register. @param[in] ClockFreq The max clock frequency to be set, the unit is MHz. @retval EFI_SUCCESS The operation is done correctly. @retval Others The operation fails. **/ EFI_STATUS EmmcSwitchClockFreq ( IN EFI_PCI_IO_PROTOCOL *PciIo, IN EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru, IN UINT8 Slot, IN UINT16 Rca, IN UINT8 HsTiming, IN UINT32 ClockFreq ) { EFI_STATUS Status; UINT8 Access; UINT8 Index; UINT8 Value; UINT8 CmdSet; UINT32 DevStatus; SD_MMC_HC_PRIVATE_DATA *Private; Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru); // // Write Byte, the Value field is written into the byte pointed by Index. // Access = 0x03; Index = OFFSET_OF (EMMC_EXT_CSD, HsTiming); Value = HsTiming; CmdSet = 0; Status = EmmcSwitch (PassThru, Slot, Access, Index, Value, CmdSet); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: Switch to hstiming %d fails with %r\n", HsTiming, Status)); return Status; } Status = EmmcSendStatus (PassThru, Slot, Rca, &DevStatus); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: Send status fails with %r\n", Status)); return Status; } // // Check the switch operation is really successful or not. // if ((DevStatus & BIT7) != 0) { DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: The switch operation fails as DevStatus is 0x%08x\n", DevStatus)); return EFI_DEVICE_ERROR; } // // Convert the clock freq unit from MHz to KHz. // Status = SdMmcHcClockSupply (PciIo, Slot, ClockFreq * 1000, Private->Capability[Slot]); return Status; }
/** Resets an SD card that is connected to the SD controller. The ResetDevice() function resets the SD card specified by Slot. If this SD controller does not support a device reset operation, EFI_UNSUPPORTED is returned. If Slot is not in a valid slot number for this SD controller, EFI_INVALID_PARAMETER is returned. If the device reset operation is completed, EFI_SUCCESS is returned. @param[in] This A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance. @param[in] Slot Specifies the slot number of the SD card to be reset. @retval EFI_SUCCESS The SD card specified by Slot was reset. @retval EFI_UNSUPPORTED The SD controller does not support a device reset operation. @retval EFI_INVALID_PARAMETER Slot number is invalid. @retval EFI_NO_MEDIA SD Device not present in the Slot. @retval EFI_DEVICE_ERROR The reset command failed due to a device error **/ EFI_STATUS EFIAPI SdMmcPassThruResetDevice ( IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This, IN UINT8 Slot ) { SD_MMC_HC_PRIVATE_DATA *Private; LIST_ENTRY *Link; LIST_ENTRY *NextLink; SD_MMC_HC_TRB *Trb; EFI_TPL OldTpl; if (This == NULL) { return EFI_INVALID_PARAMETER; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (This); if (!Private->Slot[Slot].Enable) { return EFI_INVALID_PARAMETER; } if (!Private->Slot[Slot].MediaPresent) { return EFI_NO_MEDIA; } if (!Private->Slot[Slot].Initialized) { return EFI_DEVICE_ERROR; } // // Free all async I/O requests in the queue // OldTpl = gBS->RaiseTPL (TPL_NOTIFY); for (Link = GetFirstNode (&Private->Queue); !IsNull (&Private->Queue, Link); Link = NextLink) { NextLink = GetNextNode (&Private->Queue, Link); RemoveEntryList (Link); Trb = SD_MMC_HC_TRB_FROM_THIS (Link); Trb->Packet->TransactionStatus = EFI_ABORTED; gBS->SignalEvent (Trb->Event); SdMmcFreeTrb (Trb); } gBS->RestoreTPL (OldTpl); return EFI_SUCCESS; }
/** This function retrieves an SD card slot number based on the input device path. The GetSlotNumber() function retrieves slot number for the SD card specified by the DevicePath node. If DevicePath is NULL, EFI_INVALID_PARAMETER is returned. If DevicePath is not a device path node type that the SD Pass Thru driver supports, EFI_UNSUPPORTED is returned. @param[in] This A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance. @param[in] DevicePath A pointer to the device path node that describes a SD card on the SD controller. @param[out] Slot On return, points to the slot number of an SD card on the SD controller. @retval EFI_SUCCESS SD card slot number is returned in Slot. @retval EFI_INVALID_PARAMETER Slot or DevicePath is NULL. @retval EFI_UNSUPPORTED DevicePath is not a device path node type that the SD Pass Thru driver supports. **/ EFI_STATUS EFIAPI SdMmcPassThruGetSlotNumber ( IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This, IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, OUT UINT8 *Slot ) { SD_MMC_HC_PRIVATE_DATA *Private; SD_DEVICE_PATH *SdNode; EMMC_DEVICE_PATH *EmmcNode; UINT8 SlotNumber; if ((This == NULL) || (DevicePath == NULL) || (Slot == NULL)) { return EFI_INVALID_PARAMETER; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (This); // // Check whether the DevicePath belongs to SD_DEVICE_PATH or EMMC_DEVICE_PATH // if ((DevicePath->Type != MESSAGING_DEVICE_PATH) || ((DevicePath->SubType != MSG_SD_DP) && (DevicePath->SubType != MSG_EMMC_DP)) || (DevicePathNodeLength(DevicePath) != sizeof(SD_DEVICE_PATH)) || (DevicePathNodeLength(DevicePath) != sizeof(EMMC_DEVICE_PATH))) { return EFI_UNSUPPORTED; } if (DevicePath->SubType == MSG_SD_DP) { SdNode = (SD_DEVICE_PATH *) DevicePath; SlotNumber = SdNode->SlotNumber; } else { EmmcNode = (EMMC_DEVICE_PATH *) DevicePath; SlotNumber = EmmcNode->SlotNumber; } if (SlotNumber >= SD_MMC_HC_MAX_SLOT) { return EFI_NOT_FOUND; } if (Private->Slot[SlotNumber].Enable) { *Slot = SlotNumber; return EFI_SUCCESS; } else { return EFI_NOT_FOUND; } }
/** Used to allocate and build a device path node for an SD card on the SD controller. The BuildDevicePath() function allocates and builds a single device node for the SD card specified by Slot. If the SD card specified by Slot is not present on the SD controller, then EFI_NOT_FOUND is returned. If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned. If there are not enough resources to allocate the device path node, then EFI_OUT_OF_RESOURCES is returned. Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of DevicePath are initialized to describe the SD card specified by Slot, and EFI_SUCCESS is returned. @param[in] This A pointer to the EFI_SD_MMMC_PASS_THRU_PROTOCOL instance. @param[in] Slot Specifies the slot number of the SD card for which a device path node is to be allocated and built. @param[in,out] DevicePath A pointer to a single device path node that describes the SD card specified by Slot. This function is responsible for allocating the buffer DevicePath with the boot service AllocatePool(). It is the caller's responsibility to free DevicePath when the caller is finished with DevicePath. @retval EFI_SUCCESS The device path node that describes the SD card specified by Slot was allocated and returned in DevicePath. @retval EFI_NOT_FOUND The SD card specified by Slot does not exist on the SD controller. @retval EFI_INVALID_PARAMETER DevicePath is NULL. @retval EFI_OUT_OF_RESOURCES There are not enough resources to allocate DevicePath. **/ EFI_STATUS EFIAPI SdMmcPassThruBuildDevicePath ( IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This, IN UINT8 Slot, IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath ) { SD_MMC_HC_PRIVATE_DATA *Private; SD_DEVICE_PATH *SdNode; EMMC_DEVICE_PATH *EmmcNode; if ((This == NULL) || (DevicePath == NULL) || (Slot >= SD_MMC_HC_MAX_SLOT)) { return EFI_INVALID_PARAMETER; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (This); if ((!Private->Slot[Slot].Enable) || (!Private->Slot[Slot].MediaPresent)) { return EFI_NOT_FOUND; } if (Private->Slot[Slot].CardType == SdCardType) { SdNode = AllocateCopyPool (sizeof (SD_DEVICE_PATH), &mSdDpTemplate); if (SdNode == NULL) { return EFI_OUT_OF_RESOURCES; } SdNode->SlotNumber = Slot; *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) SdNode; } else if (Private->Slot[Slot].CardType == EmmcCardType) { EmmcNode = AllocateCopyPool (sizeof (EMMC_DEVICE_PATH), &mEmmcDpTemplate); if (EmmcNode == NULL) { return EFI_OUT_OF_RESOURCES; } EmmcNode->SlotNumber = Slot; *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) EmmcNode; } else { // // Currently we only support SD and EMMC two device nodes. // return EFI_NOT_FOUND; } return EFI_SUCCESS; }
/** Used to retrieve next slot numbers supported by the SD controller. The function returns information about all available slots (populated or not-populated). The GetNextSlot() function retrieves the next slot number on an SD controller. If on input Slot is 0xFF, then the slot number of the first slot on the SD controller is returned. If Slot is a slot number that was returned on a previous call to GetNextSlot(), then the slot number of the next slot on the SD controller is returned. If Slot is not 0xFF and Slot was not returned on a previous call to GetNextSlot(), EFI_INVALID_PARAMETER is returned. If Slot is the slot number of the last slot on the SD controller, then EFI_NOT_FOUND is returned. @param[in] This A pointer to the EFI_SD_MMMC_PASS_THRU_PROTOCOL instance. @param[in,out] Slot On input, a pointer to a slot number on the SD controller. On output, a pointer to the next slot number on the SD controller. An input value of 0xFF retrieves the first slot number on the SD controller. @retval EFI_SUCCESS The next slot number on the SD controller was returned in Slot. @retval EFI_NOT_FOUND There are no more slots on this SD controller. @retval EFI_INVALID_PARAMETER Slot is not 0xFF and Slot was not returned on a previous call to GetNextSlot(). **/ EFI_STATUS EFIAPI SdMmcPassThruGetNextSlot ( IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This, IN OUT UINT8 *Slot ) { SD_MMC_HC_PRIVATE_DATA *Private; UINT8 Index; if ((This == NULL) || (Slot == NULL)) { return EFI_INVALID_PARAMETER; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (This); if (*Slot == 0xFF) { for (Index = 0; Index < SD_MMC_HC_MAX_SLOT; Index++) { if (Private->Slot[Index].Enable) { *Slot = Index; Private->PreviousSlot = Index; return EFI_SUCCESS; } } return EFI_NOT_FOUND; } else if (*Slot == Private->PreviousSlot) { for (Index = *Slot + 1; Index < SD_MMC_HC_MAX_SLOT; Index++) { if (Private->Slot[Index].Enable) { *Slot = Index; Private->PreviousSlot = Index; return EFI_SUCCESS; } } return EFI_NOT_FOUND; } else { return EFI_INVALID_PARAMETER; } }
/** Switch the high speed timing according to request. Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller Simplified Spec 3.0 Figure 2-29 for details. @param[in] PciIo A pointer to the EFI_PCI_IO_PROTOCOL instance. @param[in] PassThru A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance. @param[in] Slot The slot number of the SD card to send the command to. @param[in] Rca The relative device address to be assigned. @retval EFI_SUCCESS The operation is done correctly. @retval Others The operation fails. **/ EFI_STATUS EmmcSetBusMode ( IN EFI_PCI_IO_PROTOCOL *PciIo, IN EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru, IN UINT8 Slot, IN UINT16 Rca ) { EFI_STATUS Status; EMMC_CSD Csd; EMMC_EXT_CSD ExtCsd; UINT8 HsTiming; BOOLEAN IsDdr; UINT32 ClockFreq; UINT8 BusWidth; SD_MMC_HC_PRIVATE_DATA *Private; Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru); Status = EmmcGetCsd (PassThru, Slot, Rca, &Csd); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetCsd fails with %r\n", Status)); return Status; } Status = EmmcSelect (PassThru, Slot, Rca); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: Select fails with %r\n", Status)); return Status; } ASSERT (Private->Capability[Slot].BaseClkFreq != 0); // // Check if the Host Controller support 8bits bus width. // if (Private->Capability[Slot].BusWidth8 != 0) { BusWidth = 8; } else { BusWidth = 4; } // // Get Deivce_Type from EXT_CSD register. // Status = EmmcGetExtCsd (PassThru, Slot, &ExtCsd); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetExtCsd fails with %r\n", Status)); return Status; } // // Calculate supported bus speed/bus width/clock frequency. // HsTiming = 0; IsDdr = FALSE; ClockFreq = 0; if (((ExtCsd.DeviceType & (BIT4 | BIT5)) != 0) && (Private->Capability[Slot].Sdr104 != 0)) { HsTiming = 2; IsDdr = FALSE; ClockFreq = 200; } else if (((ExtCsd.DeviceType & (BIT2 | BIT3)) != 0) && (Private->Capability[Slot].Ddr50 != 0)) { HsTiming = 1; IsDdr = TRUE; ClockFreq = 52; } else if (((ExtCsd.DeviceType & BIT1) != 0) && (Private->Capability[Slot].HighSpeed != 0)) { HsTiming = 1; IsDdr = FALSE; ClockFreq = 52; } else if (((ExtCsd.DeviceType & BIT0) != 0) && (Private->Capability[Slot].HighSpeed != 0)) { HsTiming = 1; IsDdr = FALSE; ClockFreq = 26; } // // Check if both of the device and the host controller support HS400 DDR mode. // if (((ExtCsd.DeviceType & (BIT6 | BIT7)) != 0) && (Private->Capability[Slot].Hs400 != 0)) { // // The host controller supports 8bits bus. // ASSERT (BusWidth == 8); HsTiming = 3; IsDdr = TRUE; ClockFreq = 200; } if ((ClockFreq == 0) || (HsTiming == 0)) { // // Continue using default setting. // return EFI_SUCCESS; } DEBUG ((DEBUG_INFO, "EmmcSetBusMode: HsTiming %d ClockFreq %d BusWidth %d Ddr %a\n", HsTiming, ClockFreq, BusWidth, IsDdr ? "TRUE":"FALSE")); if (HsTiming == 3) { // // Execute HS400 timing switch procedure // Status = EmmcSwitchToHS400 (PciIo, PassThru, Slot, Rca, ClockFreq); } else if (HsTiming == 2) { // // Execute HS200 timing switch procedure // Status = EmmcSwitchToHS200 (PciIo, PassThru, Slot, Rca, ClockFreq, BusWidth); } else { // // Execute High Speed timing switch procedure // Status = EmmcSwitchToHighSpeed (PciIo, PassThru, Slot, Rca, ClockFreq, IsDdr, BusWidth); } DEBUG ((DEBUG_INFO, "EmmcSetBusMode: Switch to %a %r\n", (HsTiming == 3) ? "HS400" : ((HsTiming == 2) ? "HS200" : "HighSpeed"), Status)); return Status; }
/** Sends SD command to an SD card that is attached to the SD controller. The PassThru() function sends the SD command specified by Packet to the SD card specified by Slot. If Packet is successfully sent to the SD card, then EFI_SUCCESS is returned. If a device error occurs while sending the Packet, then EFI_DEVICE_ERROR is returned. If Slot is not in a valid range for the SD controller, then EFI_INVALID_PARAMETER is returned. If Packet defines a data command but both InDataBuffer and OutDataBuffer are NULL, EFI_INVALID_PARAMETER is returned. @param[in] This A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance. @param[in] Slot The slot number of the SD card to send the command to. @param[in,out] Packet A pointer to the SD command data structure. @param[in] Event If Event is NULL, blocking I/O is performed. If Event is not NULL, then nonblocking I/O is performed, and Event will be signaled when the Packet completes. @retval EFI_SUCCESS The SD Command Packet was sent by the host. @retval EFI_DEVICE_ERROR A device error occurred while attempting to send the SD command Packet. @retval EFI_INVALID_PARAMETER Packet, Slot, or the contents of the Packet is invalid. @retval EFI_INVALID_PARAMETER Packet defines a data command but both InDataBuffer and OutDataBuffer are NULL. @retval EFI_NO_MEDIA SD Device not present in the Slot. @retval EFI_UNSUPPORTED The command described by the SD Command Packet is not supported by the host controller. @retval EFI_BAD_BUFFER_SIZE The InTransferLength or OutTransferLength exceeds the limit supported by SD card ( i.e. if the number of bytes exceed the Last LBA). **/ EFI_STATUS EFIAPI SdMmcPassThruPassThru ( IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This, IN UINT8 Slot, IN OUT EFI_SD_MMC_PASS_THRU_COMMAND_PACKET *Packet, IN EFI_EVENT Event OPTIONAL ) { EFI_STATUS Status; SD_MMC_HC_PRIVATE_DATA *Private; SD_MMC_HC_TRB *Trb; EFI_TPL OldTpl; if ((This == NULL) || (Packet == NULL)) { return EFI_INVALID_PARAMETER; } if ((Packet->SdMmcCmdBlk == NULL) || (Packet->SdMmcStatusBlk == NULL)) { return EFI_INVALID_PARAMETER; } if ((Packet->OutDataBuffer == NULL) && (Packet->OutTransferLength != 0)) { return EFI_INVALID_PARAMETER; } if ((Packet->InDataBuffer == NULL) && (Packet->InTransferLength != 0)) { return EFI_INVALID_PARAMETER; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (This); if (!Private->Slot[Slot].Enable) { return EFI_INVALID_PARAMETER; } if (!Private->Slot[Slot].MediaPresent) { return EFI_NO_MEDIA; } if (!Private->Slot[Slot].Initialized) { return EFI_DEVICE_ERROR; } Trb = SdMmcCreateTrb (Private, Slot, Packet, Event); if (Trb == NULL) { return EFI_OUT_OF_RESOURCES; } // // Immediately return for async I/O. // if (Event != NULL) { return EFI_SUCCESS; } // // Wait async I/O list is empty before execute sync I/O operation. // while (TRUE) { OldTpl = gBS->RaiseTPL (TPL_NOTIFY); if (IsListEmpty (&Private->Queue)) { gBS->RestoreTPL (OldTpl); break; } gBS->RestoreTPL (OldTpl); } Status = SdMmcWaitTrbEnv (Private, Trb); if (EFI_ERROR (Status)) { goto Done; } Status = SdMmcExecTrb (Private, Trb); if (EFI_ERROR (Status)) { goto Done; } Status = SdMmcWaitTrbResult (Private, Trb); if (EFI_ERROR (Status)) { goto Done; } Done: if ((Trb != NULL) && (Trb->AdmaDesc != NULL)) { FreePages (Trb->AdmaDesc, Trb->AdmaPages); } if (Trb != NULL) { FreePool (Trb); } return Status; }
/** Stops a device controller or a bus controller. The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). As a result, much of the error checking on the parameters to Stop() has been moved into this common boot service. It is legal to call Stop() from other locations, but the following calling restrictions must be followed or the system behavior will not be deterministic. 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this same driver's Start() function. 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid EFI_HANDLE. In addition, all of these handles must have been created in this driver's Start() function, and the Start() function must have called OpenProtocol() on ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. @param[in] ControllerHandle A handle to the device being stopped. The handle must support a bus specific I/O protocol for the driver to use to stop the device. @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL if NumberOfChildren is 0. @retval EFI_SUCCESS The device was stopped. @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. **/ EFI_STATUS EFIAPI SdMmcPciHcDriverBindingStop ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE Controller, IN UINTN NumberOfChildren, IN EFI_HANDLE *ChildHandleBuffer ) { EFI_STATUS Status; EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; SD_MMC_HC_PRIVATE_DATA *Private; EFI_PCI_IO_PROTOCOL *PciIo; LIST_ENTRY *Link; LIST_ENTRY *NextLink; SD_MMC_HC_TRB *Trb; DEBUG ((DEBUG_INFO, "SdMmcPciHcDriverBindingStop: Start\n")); Status = gBS->OpenProtocol ( Controller, &gEfiSdMmcPassThruProtocolGuid, (VOID**) &PassThru, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); if (EFI_ERROR (Status)) { return Status; } Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru); // // Close Non-Blocking timer and free Task list. // if (Private->TimerEvent != NULL) { gBS->CloseEvent (Private->TimerEvent); Private->TimerEvent = NULL; } if (Private->ConnectEvent != NULL) { gBS->CloseEvent (Private->ConnectEvent); Private->ConnectEvent = NULL; } // // As the timer is closed, there is no needs to use TPL lock to // protect the critical region "queue". // for (Link = GetFirstNode (&Private->Queue); !IsNull (&Private->Queue, Link); Link = NextLink) { NextLink = GetNextNode (&Private->Queue, Link); RemoveEntryList (Link); Trb = SD_MMC_HC_TRB_FROM_THIS (Link); Trb->Packet->TransactionStatus = EFI_ABORTED; gBS->SignalEvent (Trb->Event); SdMmcFreeTrb (Trb); } // // Uninstall Block I/O protocol from the device handle // Status = gBS->UninstallProtocolInterface ( Controller, &gEfiSdMmcPassThruProtocolGuid, &(Private->PassThru) ); if (EFI_ERROR (Status)) { return Status; } gBS->CloseProtocol ( Controller, &gEfiPciIoProtocolGuid, This->DriverBindingHandle, Controller ); // // Restore original PCI attributes // PciIo = Private->PciIo; Status = PciIo->Attributes ( PciIo, EfiPciIoAttributeOperationSet, Private->PciAttributes, NULL ); ASSERT_EFI_ERROR (Status); FreePool (Private); DEBUG ((DEBUG_INFO, "SdMmcPciHcDriverBindingStop: End with %r\n", Status)); return Status; }