[mirror_edk2.git] / OvmfPkg / PvScsiDxe / PvScsi.c

/** @file\r
\r
  This driver produces Extended SCSI Pass Thru Protocol instances for\r
  pvscsi devices.\r
\r
  Copyright (C) 2020, Oracle and/or its affiliates.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <IndustryStandard/Pci.h>\r
#include <IndustryStandard/PvScsi.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
#include <Protocol/PciIo.h>\r
#include <Protocol/PciRootBridgeIo.h>\r
#include <Uefi/UefiSpec.h>\r
\r
#include "PvScsi.h"\r
\r
//\r
// Higher versions will be used before lower, 0x10-0xffffffef is the version\r
// range for IHV (Indie Hardware Vendors)\r
//\r
#define PVSCSI_BINDING_VERSION  0x10\r
\r
//\r
// Ext SCSI Pass Thru utilities\r
//\r
\r
/**\r
  Reads a 32-bit value into BAR0 using MMIO\r
**/\r
STATIC\r
EFI_STATUS\r
PvScsiMmioRead32 (\r
  IN CONST PVSCSI_DEV  *Dev,\r
  IN UINT64            Offset,\r
  OUT UINT32           *Value\r
  )\r
{\r
  return Dev->PciIo->Mem.Read (\r
                           Dev->PciIo,\r
                           EfiPciIoWidthUint32,\r
                           PCI_BAR_IDX0,\r
                           Offset,\r
                           1,   // Count\r
                           Value\r
                           );\r
}\r
\r
/**\r
  Writes a 32-bit value into BAR0 using MMIO\r
**/\r
STATIC\r
EFI_STATUS\r
PvScsiMmioWrite32 (\r
  IN CONST PVSCSI_DEV  *Dev,\r
  IN UINT64            Offset,\r
  IN UINT32            Value\r
  )\r
{\r
  return Dev->PciIo->Mem.Write (\r
                           Dev->PciIo,\r
                           EfiPciIoWidthUint32,\r
                           PCI_BAR_IDX0,\r
                           Offset,\r
                           1,   // Count\r
                           &Value\r
                           );\r
}\r
\r
/**\r
  Writes multiple words of data into BAR0 using MMIO\r
**/\r
STATIC\r
EFI_STATUS\r
PvScsiMmioWrite32Multiple (\r
  IN CONST PVSCSI_DEV  *Dev,\r
  IN UINT64            Offset,\r
  IN UINTN             Count,\r
  IN UINT32            *Words\r
  )\r
{\r
  return Dev->PciIo->Mem.Write (\r
                           Dev->PciIo,\r
                           EfiPciIoWidthFifoUint32,\r
                           PCI_BAR_IDX0,\r
                           Offset,\r
                           Count,\r
                           Words\r
                           );\r
}\r
\r
/**\r
  Send a PVSCSI command to device.\r
\r
  @param[in] Dev                    The pvscsi host device.\r
  @param[in] Cmd                    The command to send to device.\r
  @param[in] OPTIONAL DescWords     An optional command descriptor (If command\r
                                    have a descriptor). The descriptor is\r
                                    provided as an array of UINT32 words and\r
                                    is must be 32-bit aligned.\r
  @param[in] DescWordsCount         The number of words in command descriptor.\r
                                    Caller must specify here 0 if DescWords\r
                                    is not supplied (It is optional). In that\r
                                    case, DescWords is ignored.\r
\r
  @return   Status codes returned by Dev->PciIo->Mem.Write().\r
\r
**/\r
STATIC\r
EFI_STATUS\r
PvScsiWriteCmdDesc (\r
  IN CONST PVSCSI_DEV  *Dev,\r
  IN UINT32            Cmd,\r
  IN UINT32            *DescWords      OPTIONAL,\r
  IN UINTN             DescWordsCount\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if (DescWordsCount > PVSCSI_MAX_CMD_DATA_WORDS) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = PvScsiMmioWrite32 (Dev, PvScsiRegOffsetCommand, Cmd);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (DescWordsCount > 0) {\r
    return PvScsiMmioWrite32Multiple (\r
             Dev,\r
             PvScsiRegOffsetCommandData,\r
             DescWordsCount,\r
             DescWords\r
             );\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiResetAdapter (\r
  IN CONST PVSCSI_DEV  *Dev\r
  )\r
{\r
  return PvScsiWriteCmdDesc (Dev, PvScsiCmdAdapterReset, NULL, 0);\r
}\r
\r
/**\r
  Returns if PVSCSI request ring is full\r
**/\r
STATIC\r
BOOLEAN\r
PvScsiIsReqRingFull (\r
  IN CONST PVSCSI_DEV  *Dev\r
  )\r
{\r
  PVSCSI_RINGS_STATE  *RingsState;\r
  UINT32              ReqNumEntries;\r
\r
  RingsState    = Dev->RingDesc.RingState;\r
  ReqNumEntries = 1U << RingsState->ReqNumEntriesLog2;\r
  return (RingsState->ReqProdIdx - RingsState->CmpConsIdx) >= ReqNumEntries;\r
}\r
\r
/**\r
  Returns pointer to current request descriptor to produce\r
**/\r
STATIC\r
PVSCSI_RING_REQ_DESC *\r
PvScsiGetCurrentRequest (\r
  IN CONST PVSCSI_DEV  *Dev\r
  )\r
{\r
  PVSCSI_RINGS_STATE  *RingState;\r
  UINT32              ReqNumEntries;\r
\r
  RingState     = Dev->RingDesc.RingState;\r
  ReqNumEntries = 1U << RingState->ReqNumEntriesLog2;\r
  return Dev->RingDesc.RingReqs +\r
         (RingState->ReqProdIdx & (ReqNumEntries - 1));\r
}\r
\r
/**\r
  Returns pointer to current completion descriptor to consume\r
**/\r
STATIC\r
PVSCSI_RING_CMP_DESC *\r
PvScsiGetCurrentResponse (\r
  IN CONST PVSCSI_DEV  *Dev\r
  )\r
{\r
  PVSCSI_RINGS_STATE  *RingState;\r
  UINT32              CmpNumEntries;\r
\r
  RingState     = Dev->RingDesc.RingState;\r
  CmpNumEntries = 1U << RingState->CmpNumEntriesLog2;\r
  return Dev->RingDesc.RingCmps +\r
         (RingState->CmpConsIdx & (CmpNumEntries - 1));\r
}\r
\r
/**\r
  Wait for device to signal completion of submitted requests\r
**/\r
STATIC\r
EFI_STATUS\r
PvScsiWaitForRequestCompletion (\r
  IN CONST PVSCSI_DEV  *Dev\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT32      IntrStatus;\r
\r
  //\r
  // Note: We don't yet support Timeout according to\r
  // EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET.Timeout.\r
  //\r
  // This is consistent with some other Scsi PassThru drivers\r
  // such as VirtioScsi.\r
  //\r
  for ( ; ;) {\r
    Status = PvScsiMmioRead32 (Dev, PvScsiRegOffsetIntrStatus, &IntrStatus);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // PVSCSI_INTR_CMPL_MASK is set if device completed submitted requests\r
    //\r
    if ((IntrStatus & PVSCSI_INTR_CMPL_MASK) != 0) {\r
      break;\r
    }\r
\r
    gBS->Stall (Dev->WaitForCmpStallInUsecs);\r
  }\r
\r
  //\r
  // Acknowledge PVSCSI_INTR_CMPL_MASK in device interrupt-status register\r
  //\r
  return PvScsiMmioWrite32 (\r
           Dev,\r
           PvScsiRegOffsetIntrStatus,\r
           PVSCSI_INTR_CMPL_MASK\r
           );\r
}\r
\r
/**\r
  Create a fake host adapter error\r
**/\r
STATIC\r
EFI_STATUS\r
ReportHostAdapterError (\r
  OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet\r
  )\r
{\r
  Packet->InTransferLength  = 0;\r
  Packet->OutTransferLength = 0;\r
  Packet->SenseDataLength   = 0;\r
  Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;\r
  Packet->TargetStatus      = EFI_EXT_SCSI_STATUS_TARGET_GOOD;\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
/**\r
  Create a fake host adapter overrun error\r
**/\r
STATIC\r
EFI_STATUS\r
ReportHostAdapterOverrunError (\r
  OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet\r
  )\r
{\r
  Packet->SenseDataLength   = 0;\r
  Packet->HostAdapterStatus =\r
    EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;\r
  Packet->TargetStatus = EFI_EXT_SCSI_STATUS_TARGET_GOOD;\r
  return EFI_BAD_BUFFER_SIZE;\r
}\r
\r
/**\r
  Populate a PVSCSI request descriptor from the Extended SCSI Pass Thru\r
  Protocol packet.\r
**/\r
STATIC\r
EFI_STATUS\r
PopulateRequest (\r
  IN CONST PVSCSI_DEV                                *Dev,\r
  IN UINT8                                           *Target,\r
  IN UINT64                                          Lun,\r
  IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet,\r
  OUT PVSCSI_RING_REQ_DESC                           *Request\r
  )\r
{\r
  UINT8  TargetValue;\r
\r
  //\r
  // We only use first byte of target identifer\r
  //\r
  TargetValue = *Target;\r
\r
  //\r
  // Check for unsupported requests\r
  //\r
  if (\r
      //\r
      // Bidirectional transfer was requested\r
      //\r
      ((Packet->InTransferLength > 0) && (Packet->OutTransferLength > 0)) ||\r
      (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL) ||\r
      //\r
      // Command Descriptor Block bigger than this constant should be considered\r
      // out-of-band. We currently don't support these CDBs.\r
      //\r
      (Packet->CdbLength > PVSCSI_CDB_MAX_SIZE)\r
      )\r
  {\r
    //\r
    // This error code doesn't require updates to the Packet output fields\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Check for invalid parameters\r
  //\r
  if (\r
      //\r
      // Addressed invalid device\r
      //\r
      (TargetValue > Dev->MaxTarget) || (Lun > Dev->MaxLun) ||\r
      //\r
      // Invalid direction (there doesn't seem to be a macro for the "no data\r
      // transferred" "direction", eg. for TEST UNIT READY)\r
      //\r
      (Packet->DataDirection > EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL) ||\r
      //\r
      // Trying to receive, but destination pointer is NULL, or contradicting\r
      // transfer direction\r
      //\r
      ((Packet->InTransferLength > 0) &&\r
       ((Packet->InDataBuffer == NULL) ||\r
        (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_WRITE)\r
       )\r
      ) ||\r
      //\r
      // Trying to send, but source pointer is NULL, or contradicting\r
      // transfer direction\r
      //\r
      ((Packet->OutTransferLength > 0) &&\r
       ((Packet->OutDataBuffer == NULL) ||\r
        (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ)\r
       )\r
      )\r
      )\r
  {\r
    //\r
    // This error code doesn't require updates to the Packet output fields\r
    //\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Check for input/output buffer too large for DMA communication buffer\r
  //\r
  if (Packet->InTransferLength > sizeof (Dev->DmaBuf->Data)) {\r
    Packet->InTransferLength = sizeof (Dev->DmaBuf->Data);\r
    return ReportHostAdapterOverrunError (Packet);\r
  }\r
\r
  if (Packet->OutTransferLength > sizeof (Dev->DmaBuf->Data)) {\r
    Packet->OutTransferLength = sizeof (Dev->DmaBuf->Data);\r
    return ReportHostAdapterOverrunError (Packet);\r
  }\r
\r
  //\r
  // Encode PVSCSI request\r
  //\r
  ZeroMem (Request, sizeof (*Request));\r
\r
  Request->Bus    = 0;\r
  Request->Target = TargetValue;\r
  //\r
  // This cast is safe as PVSCSI_DEV.MaxLun is defined as UINT8\r
  //\r
  Request->Lun[1]   = (UINT8)Lun;\r
  Request->SenseLen = Packet->SenseDataLength;\r
  //\r
  // DMA communication buffer SenseData overflow is not possible\r
  // due to Packet->SenseDataLength defined as UINT8\r
  //\r
  Request->SenseAddr = PVSCSI_DMA_BUF_DEV_ADDR (Dev, SenseData);\r
  Request->CdbLen    = Packet->CdbLength;\r
  CopyMem (Request->Cdb, Packet->Cdb, Packet->CdbLength);\r
  Request->VcpuHint = 0;\r
  Request->Tag      = PVSCSI_SIMPLE_QUEUE_TAG;\r
  if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {\r
    Request->Flags   = PVSCSI_FLAG_CMD_DIR_TOHOST;\r
    Request->DataLen = Packet->InTransferLength;\r
  } else {\r
    Request->Flags   = PVSCSI_FLAG_CMD_DIR_TODEVICE;\r
    Request->DataLen = Packet->OutTransferLength;\r
    CopyMem (\r
      Dev->DmaBuf->Data,\r
      Packet->OutDataBuffer,\r
      Packet->OutTransferLength\r
      );\r
  }\r
\r
  Request->DataAddr = PVSCSI_DMA_BUF_DEV_ADDR (Dev, Data);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Handle the PVSCSI device response:\r
  - Copy returned data from DMA communication buffer.\r
  - Update fields in Extended SCSI Pass Thru Protocol packet as required.\r
  - Translate response code to EFI status code and host adapter status.\r
**/\r
STATIC\r
EFI_STATUS\r
HandleResponse (\r
  IN PVSCSI_DEV                                      *Dev,\r
  IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet,\r
  IN CONST PVSCSI_RING_CMP_DESC                      *Response\r
  )\r
{\r
  //\r
  // Fix SenseDataLength to amount of data returned\r
  //\r
  if (Packet->SenseDataLength > Response->SenseLen) {\r
    Packet->SenseDataLength = (UINT8)Response->SenseLen;\r
  }\r
\r
  //\r
  // Copy sense data from DMA communication buffer\r
  //\r
  CopyMem (\r
    Packet->SenseData,\r
    Dev->DmaBuf->SenseData,\r
    Packet->SenseDataLength\r
    );\r
\r
  //\r
  // Copy device output from DMA communication buffer\r
  //\r
  if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {\r
    CopyMem (Packet->InDataBuffer, Dev->DmaBuf->Data, Packet->InTransferLength);\r
  }\r
\r
  //\r
  // Report target status\r
  // (Strangely, PVSCSI interface defines Response->ScsiStatus as UINT16.\r
  // But it should de-facto always have a value that fits UINT8. To avoid\r
  // unexpected behavior, verify value is in UINT8 bounds before casting)\r
  //\r
  ASSERT (Response->ScsiStatus <= MAX_UINT8);\r
  Packet->TargetStatus = (UINT8)Response->ScsiStatus;\r
\r
  //\r
  // Host adapter status and function return value depend on\r
  // device response's host status\r
  //\r
  switch (Response->HostStatus) {\r
    case PvScsiBtStatSuccess:\r
    case PvScsiBtStatLinkedCommandCompleted:\r
    case PvScsiBtStatLinkedCommandCompletedWithFlag:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK;\r
      return EFI_SUCCESS;\r
\r
    case PvScsiBtStatDataUnderrun:\r
      //\r
      // Report transferred amount in underrun\r
      //\r
      if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {\r
        Packet->InTransferLength = (UINT32)Response->DataLen;\r
      } else {\r
        Packet->OutTransferLength = (UINT32)Response->DataLen;\r
      }\r
\r
      Packet->HostAdapterStatus =\r
        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;\r
      return EFI_SUCCESS;\r
\r
    case PvScsiBtStatDatarun:\r
      Packet->HostAdapterStatus =\r
        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;\r
      return EFI_SUCCESS;\r
\r
    case PvScsiBtStatSelTimeout:\r
      Packet->HostAdapterStatus =\r
        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT;\r
      return EFI_TIMEOUT;\r
\r
    case PvScsiBtStatBusFree:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_FREE;\r
      break;\r
\r
    case PvScsiBtStatInvPhase:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR;\r
      break;\r
\r
    case PvScsiBtStatSensFailed:\r
      Packet->HostAdapterStatus =\r
        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED;\r
      break;\r
\r
    case PvScsiBtStatTagReject:\r
    case PvScsiBtStatBadMsg:\r
      Packet->HostAdapterStatus =\r
        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT;\r
      break;\r
\r
    case PvScsiBtStatBusReset:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET;\r
      break;\r
\r
    case PvScsiBtStatHaTimeout:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT;\r
      return EFI_TIMEOUT;\r
\r
    case PvScsiBtStatScsiParity:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR;\r
      break;\r
\r
    default:\r
      Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;\r
      break;\r
  }\r
\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
/**\r
  Check if Target argument to EXT_SCSI_PASS_THRU.GetNextTarget() and\r
  EXT_SCSI_PASS_THRU.GetNextTargetLun() is initialized\r
**/\r
STATIC\r
BOOLEAN\r
IsTargetInitialized (\r
  IN UINT8  *Target\r
  )\r
{\r
  UINTN  Idx;\r
\r
  for (Idx = 0; Idx < TARGET_MAX_BYTES; ++Idx) {\r
    if (Target[Idx] != 0xFF) {\r
      return TRUE;\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
//\r
// Ext SCSI Pass Thru\r
//\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiPassThru (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL                 *This,\r
  IN UINT8                                           *Target,\r
  IN UINT64                                          Lun,\r
  IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet,\r
  IN EFI_EVENT                                       Event    OPTIONAL\r
  )\r
{\r
  PVSCSI_DEV            *Dev;\r
  EFI_STATUS            Status;\r
  PVSCSI_RING_REQ_DESC  *Request;\r
  PVSCSI_RING_CMP_DESC  *Response;\r
\r
  Dev = PVSCSI_FROM_PASS_THRU (This);\r
\r
  if (PvScsiIsReqRingFull (Dev)) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  Request = PvScsiGetCurrentRequest (Dev);\r
\r
  Status = PopulateRequest (Dev, Target, Lun, Packet, Request);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Writes to Request must be globally visible before making request\r
  // available to device\r
  //\r
  MemoryFence ();\r
  Dev->RingDesc.RingState->ReqProdIdx++;\r
\r
  Status = PvScsiMmioWrite32 (Dev, PvScsiRegOffsetKickRwIo, 0);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // If kicking the host fails, we must fake a host adapter error.\r
    // EFI_NOT_READY would save us the effort, but it would also suggest that\r
    // the caller retry.\r
    //\r
    return ReportHostAdapterError (Packet);\r
  }\r
\r
  Status = PvScsiWaitForRequestCompletion (Dev);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // If waiting for request completion fails, we must fake a host adapter\r
    // error. EFI_NOT_READY would save us the effort, but it would also suggest\r
    // that the caller retry.\r
    //\r
    return ReportHostAdapterError (Packet);\r
  }\r
\r
  Response = PvScsiGetCurrentResponse (Dev);\r
  Status   = HandleResponse (Dev, Packet, Response);\r
\r
  //\r
  // Reads from response must complete before releasing completion entry\r
  // to device\r
  //\r
  MemoryFence ();\r
  Dev->RingDesc.RingState->CmpConsIdx++;\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiGetNextTargetLun (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This,\r
  IN OUT UINT8                        **Target,\r
  IN OUT UINT64                       *Lun\r
  )\r
{\r
  UINT8       *TargetPtr;\r
  UINT8       LastTarget;\r
  PVSCSI_DEV  *Dev;\r
\r
  if (Target == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // The Target input parameter is unnecessarily a pointer-to-pointer\r
  //\r
  TargetPtr = *Target;\r
\r
  //\r
  // If target not initialized, return first target & LUN\r
  //\r
  if (!IsTargetInitialized (TargetPtr)) {\r
    ZeroMem (TargetPtr, TARGET_MAX_BYTES);\r
    *Lun = 0;\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // We only use first byte of target identifer\r
  //\r
  LastTarget = *TargetPtr;\r
\r
  //\r
  // Increment (target, LUN) pair if valid on input\r
  //\r
  Dev = PVSCSI_FROM_PASS_THRU (This);\r
  if ((LastTarget > Dev->MaxTarget) || (*Lun > Dev->MaxLun)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (*Lun < Dev->MaxLun) {\r
    ++*Lun;\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (LastTarget < Dev->MaxTarget) {\r
    *Lun = 0;\r
    ++LastTarget;\r
    *TargetPtr = LastTarget;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiBuildDevicePath (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This,\r
  IN UINT8                            *Target,\r
  IN UINT64                           Lun,\r
  IN OUT EFI_DEVICE_PATH_PROTOCOL     **DevicePath\r
  )\r
{\r
  UINT8             TargetValue;\r
  PVSCSI_DEV        *Dev;\r
  SCSI_DEVICE_PATH  *ScsiDevicePath;\r
\r
  if (DevicePath == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // We only use first byte of target identifer\r
  //\r
  TargetValue = *Target;\r
\r
  Dev = PVSCSI_FROM_PASS_THRU (This);\r
  if ((TargetValue > Dev->MaxTarget) || (Lun > Dev->MaxLun)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  ScsiDevicePath = AllocatePool (sizeof (*ScsiDevicePath));\r
  if (ScsiDevicePath == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  ScsiDevicePath->Header.Type      = MESSAGING_DEVICE_PATH;\r
  ScsiDevicePath->Header.SubType   = MSG_SCSI_DP;\r
  ScsiDevicePath->Header.Length[0] = (UINT8)sizeof (*ScsiDevicePath);\r
  ScsiDevicePath->Header.Length[1] = (UINT8)(sizeof (*ScsiDevicePath) >> 8);\r
  ScsiDevicePath->Pun              = TargetValue;\r
  ScsiDevicePath->Lun              = (UINT16)Lun;\r
\r
  *DevicePath = &ScsiDevicePath->Header;\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiGetTargetLun (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This,\r
  IN EFI_DEVICE_PATH_PROTOCOL         *DevicePath,\r
  OUT UINT8                           **Target,\r
  OUT UINT64                          *Lun\r
  )\r
{\r
  SCSI_DEVICE_PATH  *ScsiDevicePath;\r
  PVSCSI_DEV        *Dev;\r
\r
  if ((DevicePath == NULL) || (Target == NULL) || (*Target == NULL) || (Lun == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((DevicePath->Type    != MESSAGING_DEVICE_PATH) ||\r
      (DevicePath->SubType != MSG_SCSI_DP))\r
  {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  ScsiDevicePath = (SCSI_DEVICE_PATH *)DevicePath;\r
  Dev            = PVSCSI_FROM_PASS_THRU (This);\r
  if ((ScsiDevicePath->Pun > Dev->MaxTarget) ||\r
      (ScsiDevicePath->Lun > Dev->MaxLun))\r
  {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // We only use first byte of target identifer\r
  //\r
  **Target = (UINT8)ScsiDevicePath->Pun;\r
  ZeroMem (*Target + 1, TARGET_MAX_BYTES - 1);\r
  *Lun = ScsiDevicePath->Lun;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiResetChannel (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiResetTargetLun (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This,\r
  IN UINT8                            *Target,\r
  IN UINT64                           Lun\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiGetNextTarget (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *This,\r
  IN OUT UINT8                        **Target\r
  )\r
{\r
  UINT8       *TargetPtr;\r
  UINT8       LastTarget;\r
  PVSCSI_DEV  *Dev;\r
\r
  if (Target == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // The Target input parameter is unnecessarily a pointer-to-pointer\r
  //\r
  TargetPtr = *Target;\r
\r
  //\r
  // If target not initialized, return first target\r
  //\r
  if (!IsTargetInitialized (TargetPtr)) {\r
    ZeroMem (TargetPtr, TARGET_MAX_BYTES);\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // We only use first byte of target identifer\r
  //\r
  LastTarget = *TargetPtr;\r
\r
  //\r
  // Increment target if valid on input\r
  //\r
  Dev = PVSCSI_FROM_PASS_THRU (This);\r
  if (LastTarget > Dev->MaxTarget) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (LastTarget < Dev->MaxTarget) {\r
    ++LastTarget;\r
    *TargetPtr = LastTarget;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiSetPciAttributes (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Backup original PCI Attributes\r
  //\r
  Status = Dev->PciIo->Attributes (\r
                         Dev->PciIo,\r
                         EfiPciIoAttributeOperationGet,\r
                         0,\r
                         &Dev->OriginalPciAttributes\r
                         );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Enable MMIO-Space & Bus-Mastering\r
  //\r
  Status = Dev->PciIo->Attributes (\r
                         Dev->PciIo,\r
                         EfiPciIoAttributeOperationEnable,\r
                         (EFI_PCI_IO_ATTRIBUTE_MEMORY |\r
                          EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),\r
                         NULL\r
                         );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Signal device supports 64-bit DMA addresses\r
  //\r
  Status = Dev->PciIo->Attributes (\r
                         Dev->PciIo,\r
                         EfiPciIoAttributeOperationEnable,\r
                         EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE,\r
                         NULL\r
                         );\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Warn user that device will only be using 32-bit DMA addresses.\r
    //\r
    // Note that this does not prevent the device/driver from working\r
    // and therefore we only warn and continue as usual.\r
    //\r
    DEBUG ((\r
      DEBUG_WARN,\r
      "%a: failed to enable 64-bit DMA addresses\n",\r
      __FUNCTION__\r
      ));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
VOID\r
PvScsiRestorePciAttributes (\r
  IN PVSCSI_DEV  *Dev\r
  )\r
{\r
  Dev->PciIo->Attributes (\r
                Dev->PciIo,\r
                EfiPciIoAttributeOperationSet,\r
                Dev->OriginalPciAttributes,\r
                NULL\r
                );\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiAllocateSharedPages (\r
  IN PVSCSI_DEV        *Dev,\r
  IN UINTN             Pages,\r
  OUT VOID             **HostAddress,\r
  OUT PVSCSI_DMA_DESC  *DmaDesc\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       NumberOfBytes;\r
\r
  Status = Dev->PciIo->AllocateBuffer (\r
                         Dev->PciIo,\r
                         AllocateAnyPages,\r
                         EfiBootServicesData,\r
                         Pages,\r
                         HostAddress,\r
                         EFI_PCI_ATTRIBUTE_MEMORY_CACHED\r
                         );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  NumberOfBytes = EFI_PAGES_TO_SIZE (Pages);\r
  Status        = Dev->PciIo->Map (\r
                                Dev->PciIo,\r
                                EfiPciIoOperationBusMasterCommonBuffer,\r
                                *HostAddress,\r
                                &NumberOfBytes,\r
                                &DmaDesc->DeviceAddress,\r
                                &DmaDesc->Mapping\r
                                );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeBuffer;\r
  }\r
\r
  if (NumberOfBytes != EFI_PAGES_TO_SIZE (Pages)) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Unmap;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
Unmap:\r
  Dev->PciIo->Unmap (Dev->PciIo, DmaDesc->Mapping);\r
\r
FreeBuffer:\r
  Dev->PciIo->FreeBuffer (Dev->PciIo, Pages, *HostAddress);\r
\r
  return Status;\r
}\r
\r
STATIC\r
VOID\r
PvScsiFreeSharedPages (\r
  IN PVSCSI_DEV       *Dev,\r
  IN UINTN            Pages,\r
  IN VOID             *HostAddress,\r
  IN PVSCSI_DMA_DESC  *DmaDesc\r
  )\r
{\r
  Dev->PciIo->Unmap (Dev->PciIo, DmaDesc->Mapping);\r
  Dev->PciIo->FreeBuffer (Dev->PciIo, Pages, HostAddress);\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiInitRings (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = PvScsiAllocateSharedPages (\r
             Dev,\r
             1,\r
             (VOID **)&Dev->RingDesc.RingState,\r
             &Dev->RingDesc.RingStateDmaDesc\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  ZeroMem (Dev->RingDesc.RingState, EFI_PAGE_SIZE);\r
\r
  Status = PvScsiAllocateSharedPages (\r
             Dev,\r
             1,\r
             (VOID **)&Dev->RingDesc.RingReqs,\r
             &Dev->RingDesc.RingReqsDmaDesc\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeRingState;\r
  }\r
\r
  ZeroMem (Dev->RingDesc.RingReqs, EFI_PAGE_SIZE);\r
\r
  Status = PvScsiAllocateSharedPages (\r
             Dev,\r
             1,\r
             (VOID **)&Dev->RingDesc.RingCmps,\r
             &Dev->RingDesc.RingCmpsDmaDesc\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeRingReqs;\r
  }\r
\r
  ZeroMem (Dev->RingDesc.RingCmps, EFI_PAGE_SIZE);\r
\r
  return EFI_SUCCESS;\r
\r
FreeRingReqs:\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    1,\r
    Dev->RingDesc.RingReqs,\r
    &Dev->RingDesc.RingReqsDmaDesc\r
    );\r
\r
FreeRingState:\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    1,\r
    Dev->RingDesc.RingState,\r
    &Dev->RingDesc.RingStateDmaDesc\r
    );\r
\r
  return Status;\r
}\r
\r
STATIC\r
VOID\r
PvScsiFreeRings (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    1,\r
    Dev->RingDesc.RingCmps,\r
    &Dev->RingDesc.RingCmpsDmaDesc\r
    );\r
\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    1,\r
    Dev->RingDesc.RingReqs,\r
    &Dev->RingDesc.RingReqsDmaDesc\r
    );\r
\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    1,\r
    Dev->RingDesc.RingState,\r
    &Dev->RingDesc.RingStateDmaDesc\r
    );\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiSetupRings (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  union {\r
    PVSCSI_CMD_DESC_SETUP_RINGS    Cmd;\r
    UINT32                         Uint32;\r
  } AlignedCmd;\r
  PVSCSI_CMD_DESC_SETUP_RINGS  *Cmd;\r
\r
  Cmd = &AlignedCmd.Cmd;\r
\r
  ZeroMem (Cmd, sizeof (*Cmd));\r
  Cmd->ReqRingNumPages = 1;\r
  Cmd->CmpRingNumPages = 1;\r
  Cmd->RingsStatePPN   = RShiftU64 (\r
                           Dev->RingDesc.RingStateDmaDesc.DeviceAddress,\r
                           EFI_PAGE_SHIFT\r
                           );\r
  Cmd->ReqRingPPNs[0] = RShiftU64 (\r
                          Dev->RingDesc.RingReqsDmaDesc.DeviceAddress,\r
                          EFI_PAGE_SHIFT\r
                          );\r
  Cmd->CmpRingPPNs[0] = RShiftU64 (\r
                          Dev->RingDesc.RingCmpsDmaDesc.DeviceAddress,\r
                          EFI_PAGE_SHIFT\r
                          );\r
\r
  STATIC_ASSERT (\r
    sizeof (*Cmd) % sizeof (UINT32) == 0,\r
    "Cmd must be multiple of 32-bit words"\r
    );\r
  return PvScsiWriteCmdDesc (\r
           Dev,\r
           PvScsiCmdSetupRings,\r
           (UINT32 *)Cmd,\r
           sizeof (*Cmd) / sizeof (UINT32)\r
           );\r
}\r
\r
STATIC\r
EFI_STATUS\r
PvScsiInit (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Init configuration\r
  //\r
  Dev->MaxTarget              = PcdGet8 (PcdPvScsiMaxTargetLimit);\r
  Dev->MaxLun                 = PcdGet8 (PcdPvScsiMaxLunLimit);\r
  Dev->WaitForCmpStallInUsecs = PcdGet32 (PcdPvScsiWaitForCmpStallInUsecs);\r
\r
  //\r
  // Set PCI Attributes\r
  //\r
  Status = PvScsiSetPciAttributes (Dev);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Reset adapter\r
  //\r
  Status = PvScsiResetAdapter (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto RestorePciAttributes;\r
  }\r
\r
  //\r
  // Init PVSCSI rings\r
  //\r
  Status = PvScsiInitRings (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto RestorePciAttributes;\r
  }\r
\r
  //\r
  // Allocate DMA communication buffer\r
  //\r
  Status = PvScsiAllocateSharedPages (\r
             Dev,\r
             EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),\r
             (VOID **)&Dev->DmaBuf,\r
             &Dev->DmaBufDmaDesc\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeRings;\r
  }\r
\r
  //\r
  // Setup rings against device\r
  //\r
  Status = PvScsiSetupRings (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto FreeDmaCommBuffer;\r
  }\r
\r
  //\r
  // Populate the exported interface's attributes\r
  //\r
  Dev->PassThru.Mode             = &Dev->PassThruMode;\r
  Dev->PassThru.PassThru         = &PvScsiPassThru;\r
  Dev->PassThru.GetNextTargetLun = &PvScsiGetNextTargetLun;\r
  Dev->PassThru.BuildDevicePath  = &PvScsiBuildDevicePath;\r
  Dev->PassThru.GetTargetLun     = &PvScsiGetTargetLun;\r
  Dev->PassThru.ResetChannel     = &PvScsiResetChannel;\r
  Dev->PassThru.ResetTargetLun   = &PvScsiResetTargetLun;\r
  Dev->PassThru.GetNextTarget    = &PvScsiGetNextTarget;\r
\r
  //\r
  // AdapterId is a target for which no handle will be created during bus scan.\r
  // Prevent any conflict with real devices.\r
  //\r
  Dev->PassThruMode.AdapterId = MAX_UINT32;\r
\r
  //\r
  // Set both physical and logical attributes for non-RAID SCSI channel\r
  //\r
  Dev->PassThruMode.Attributes = EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL |\r
                                 EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL;\r
\r
  //\r
  // No restriction on transfer buffer alignment\r
  //\r
  Dev->PassThruMode.IoAlign = 0;\r
\r
  return EFI_SUCCESS;\r
\r
FreeDmaCommBuffer:\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),\r
    Dev->DmaBuf,\r
    &Dev->DmaBufDmaDesc\r
    );\r
\r
FreeRings:\r
  PvScsiFreeRings (Dev);\r
\r
RestorePciAttributes:\r
  PvScsiRestorePciAttributes (Dev);\r
\r
  return Status;\r
}\r
\r
STATIC\r
VOID\r
PvScsiUninit (\r
  IN OUT PVSCSI_DEV  *Dev\r
  )\r
{\r
  //\r
  // Reset device to:\r
  // - Make device stop processing all requests.\r
  // - Stop device usage of the rings.\r
  //\r
  // This is required to safely free the DMA communication buffer\r
  // and the rings.\r
  //\r
  PvScsiResetAdapter (Dev);\r
\r
  //\r
  // Free DMA communication buffer\r
  //\r
  PvScsiFreeSharedPages (\r
    Dev,\r
    EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),\r
    Dev->DmaBuf,\r
    &Dev->DmaBufDmaDesc\r
    );\r
\r
  PvScsiFreeRings (Dev);\r
\r
  PvScsiRestorePciAttributes (Dev);\r
}\r
\r
/**\r
  Event notification called by ExitBootServices()\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
PvScsiExitBoot (\r
  IN  EFI_EVENT  Event,\r
  IN  VOID       *Context\r
  )\r
{\r
  PVSCSI_DEV  *Dev;\r
\r
  Dev = Context;\r
  DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));\r
\r
  //\r
  // Reset the device to stop device usage of the rings.\r
  //\r
  // We allocated said rings in EfiBootServicesData type memory, and code\r
  // executing after ExitBootServices() is permitted to overwrite it.\r
  //\r
  PvScsiResetAdapter (Dev);\r
}\r
\r
//\r
// Driver Binding\r
//\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL\r
  )\r
{\r
  EFI_STATUS           Status;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  PCI_TYPE00           Pci;\r
\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&PciIo,\r
                  This->DriverBindingHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint32,\r
                        0,\r
                        sizeof (Pci) / sizeof (UINT32),\r
                        &Pci\r
                        );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  if ((Pci.Hdr.VendorId != PCI_VENDOR_ID_VMWARE) ||\r
      (Pci.Hdr.DeviceId != PCI_DEVICE_ID_VMWARE_PVSCSI))\r
  {\r
    Status = EFI_UNSUPPORTED;\r
    goto Done;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
Done:\r
  gBS->CloseProtocol (\r
         ControllerHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         ControllerHandle\r
         );\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL\r
  )\r
{\r
  PVSCSI_DEV  *Dev;\r
  EFI_STATUS  Status;\r
\r
  Dev = (PVSCSI_DEV *)AllocateZeroPool (sizeof (*Dev));\r
  if (Dev == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&Dev->PciIo,\r
                  This->DriverBindingHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto FreePvScsi;\r
  }\r
\r
  Status = PvScsiInit (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto ClosePciIo;\r
  }\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_SIGNAL_EXIT_BOOT_SERVICES,\r
                  TPL_CALLBACK,\r
                  &PvScsiExitBoot,\r
                  Dev,\r
                  &Dev->ExitBoot\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto UninitDev;\r
  }\r
\r
  //\r
  // Setup complete, attempt to export the driver instance's PassThru interface\r
  //\r
  Dev->Signature = PVSCSI_SIG;\r
  Status         = gBS->InstallProtocolInterface (\r
                          &ControllerHandle,\r
                          &gEfiExtScsiPassThruProtocolGuid,\r
                          EFI_NATIVE_INTERFACE,\r
                          &Dev->PassThru\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    goto CloseExitBoot;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
CloseExitBoot:\r
  gBS->CloseEvent (Dev->ExitBoot);\r
\r
UninitDev:\r
  PvScsiUninit (Dev);\r
\r
ClosePciIo:\r
  gBS->CloseProtocol (\r
         ControllerHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         ControllerHandle\r
         );\r
\r
FreePvScsi:\r
  FreePool (Dev);\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiDriverBindingStop (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN UINTN                        NumberOfChildren,\r
  IN EFI_HANDLE                   *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  EFI_EXT_SCSI_PASS_THRU_PROTOCOL  *PassThru;\r
  PVSCSI_DEV                       *Dev;\r
\r
  Status = gBS->OpenProtocol (\r
                  ControllerHandle,\r
                  &gEfiExtScsiPassThruProtocolGuid,\r
                  (VOID **)&PassThru,\r
                  This->DriverBindingHandle,\r
                  ControllerHandle,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL // Lookup only\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Dev = PVSCSI_FROM_PASS_THRU (PassThru);\r
\r
  Status = gBS->UninstallProtocolInterface (\r
                  ControllerHandle,\r
                  &gEfiExtScsiPassThruProtocolGuid,\r
                  &Dev->PassThru\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  gBS->CloseEvent (Dev->ExitBoot);\r
\r
  PvScsiUninit (Dev);\r
\r
  gBS->CloseProtocol (\r
         ControllerHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         ControllerHandle\r
         );\r
\r
  FreePool (Dev);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC EFI_DRIVER_BINDING_PROTOCOL  mPvScsiDriverBinding = {\r
  &PvScsiDriverBindingSupported,\r
  &PvScsiDriverBindingStart,\r
  &PvScsiDriverBindingStop,\r
  PVSCSI_BINDING_VERSION,\r
  NULL, // ImageHandle, filled by EfiLibInstallDriverBindingComponentName2()\r
  NULL  // DriverBindingHandle, filled as well\r
};\r
\r
//\r
// Component Name\r
//\r
\r
STATIC EFI_UNICODE_STRING_TABLE  mDriverNameTable[] = {\r
  { "eng;en", L"PVSCSI Host Driver" },\r
  { NULL,     NULL                  }\r
};\r
\r
STATIC EFI_COMPONENT_NAME_PROTOCOL  mComponentName;\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiGetDriverName (\r
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,\r
  IN  CHAR8                        *Language,\r
  OUT CHAR16                       **DriverName\r
  )\r
{\r
  return LookupUnicodeString2 (\r
           Language,\r
           This->SupportedLanguages,\r
           mDriverNameTable,\r
           DriverName,\r
           (BOOLEAN)(This == &mComponentName) // Iso639Language\r
           );\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PvScsiGetDeviceName (\r
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,\r
  IN  EFI_HANDLE                   DeviceHandle,\r
  IN  EFI_HANDLE                   ChildHandle,\r
  IN  CHAR8                        *Language,\r
  OUT CHAR16                       **ControllerName\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
STATIC EFI_COMPONENT_NAME_PROTOCOL  mComponentName = {\r
  &PvScsiGetDriverName,\r
  &PvScsiGetDeviceName,\r
  "eng" // SupportedLanguages, ISO 639-2 language codes\r
};\r
\r
STATIC EFI_COMPONENT_NAME2_PROTOCOL  mComponentName2 = {\r
  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)&PvScsiGetDriverName,\r
  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)&PvScsiGetDeviceName,\r
  "en" // SupportedLanguages, RFC 4646 language codes\r
};\r
\r
//\r
// Entry Point\r
//\r
\r
EFI_STATUS\r
EFIAPI\r
PvScsiEntryPoint (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  return EfiLibInstallDriverBindingComponentName2 (\r
           ImageHandle,\r
           SystemTable,\r
           &mPvScsiDriverBinding,\r
           ImageHandle,\r
           &mComponentName,\r
           &mComponentName2\r
           );\r
}\r