[mirror_edk2.git] / OvmfPkg / VirtioScsiDxe / VirtioScsi.c

/** @file\r
\r
  This driver produces Extended SCSI Pass Thru Protocol instances for\r
  virtio-scsi devices.\r
\r
  The implementation is basic:\r
\r
  - No hotplug / hot-unplug.\r
\r
  - Although EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() could be a good match\r
    for multiple in-flight virtio-scsi requests, we stick to synchronous\r
    requests for now.\r
\r
  - Timeouts are not supported for EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru().\r
\r
  - Only one channel is supported. (At the time of this writing, host-side\r
    virtio-scsi supports a single channel too.)\r
\r
  - Only one request queue is used (for the one synchronous request).\r
\r
  - The ResetChannel() and ResetTargetLun() functions of\r
    EFI_EXT_SCSI_PASS_THRU_PROTOCOL are not supported (which is allowed by the\r
    UEFI 2.3.1 Errata C specification), although\r
    VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET could be a good match. That would\r
    however require client code for the control queue, which is deemed\r
    unreasonable for now.\r
\r
  Copyright (C) 2012, Red Hat, Inc.\r
  Copyright (c) 2012 - 2014, Intel Corporation. All rights reserved.<BR>\r
  Copyright (c) 2017, AMD Inc, All rights reserved.<BR>\r
\r
  This program and the accompanying materials are licensed and made available\r
  under the terms and conditions of the BSD License which accompanies this\r
  distribution. The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include <IndustryStandard/VirtioScsi.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/VirtioLib.h>\r
\r
#include "VirtioScsi.h"\r
\r
/**\r
\r
  Convenience macros to read and write configuration elements of the\r
  virtio-scsi VirtIo device.\r
\r
  The following macros make it possible to specify only the "core parameters"\r
  for such accesses and to derive the rest. By the time VIRTIO_CFG_WRITE()\r
  returns, the transaction will have been completed.\r
\r
  @param[in] Dev       Pointer to the VSCSI_DEV structure.\r
\r
  @param[in] Field     A field name from VSCSI_HDR, identifying the virtio-scsi\r
                       configuration item to access.\r
\r
  @param[in] Value     (VIRTIO_CFG_WRITE() only.) The value to write to the\r
                       selected configuration item.\r
\r
  @param[out] Pointer  (VIRTIO_CFG_READ() only.) The object to receive the\r
                       value read from the configuration item. Its type must be\r
                       one of UINT8, UINT16, UINT32, UINT64.\r
\r
\r
  @return  Status codes returned by Virtio->WriteDevice() / Virtio->ReadDevice().\r
\r
**/\r
\r
#define VIRTIO_CFG_WRITE(Dev, Field, Value)  ((Dev)->VirtIo->WriteDevice (  \\r
                                                (Dev)->VirtIo,              \\r
                                                OFFSET_OF_VSCSI (Field),    \\r
                                                SIZE_OF_VSCSI (Field),      \\r
                                                (Value)                     \\r
                                                ))\r
\r
#define VIRTIO_CFG_READ(Dev, Field, Pointer) ((Dev)->VirtIo->ReadDevice (   \\r
                                                (Dev)->VirtIo,              \\r
                                                OFFSET_OF_VSCSI (Field),    \\r
                                                SIZE_OF_VSCSI (Field),      \\r
                                                sizeof *(Pointer),          \\r
                                                (Pointer)                   \\r
                                                ))\r
\r
\r
//\r
// UEFI Spec 2.3.1 + Errata C, 14.7 Extended SCSI Pass Thru Protocol specifies\r
// the PassThru() interface. Beside returning a status code, the function must\r
// set some fields in the EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET in/out\r
// parameter on return. The following is a full list of those fields, for\r
// easier validation of PopulateRequest(), ParseResponse(), and\r
// ReportHostAdapterError() below.\r
//\r
// - InTransferLength\r
// - OutTransferLength\r
// - HostAdapterStatus\r
// - TargetStatus\r
// - SenseDataLength\r
// - SenseData\r
//\r
// On any return from the PassThru() interface, these fields must be set,\r
// except if the returned status code is explicitly exempt. (Actually the\r
// implementation here conservatively sets these fields even in case not all\r
// of them would be required by the specification.)\r
//\r
\r
/**\r
\r
  Populate a virtio-scsi request from the Extended SCSI Pass Thru Protocol\r
  packet.\r
\r
  The caller is responsible for pre-zeroing the virtio-scsi request. The\r
  Extended SCSI Pass Thru Protocol packet is modified, to be forwarded outwards\r
  by VirtioScsiPassThru(), if invalid or unsupported parameters are detected.\r
\r
  @param[in] Dev          The virtio-scsi host device the packet targets.\r
\r
  @param[in] Target       The SCSI target controlled by the virtio-scsi host\r
                          device.\r
\r
  @param[in] Lun          The Logical Unit Number under the SCSI target.\r
\r
  @param[in out] Packet   The Extended SCSI Pass Thru Protocol packet the\r
                          function translates to a virtio-scsi request. On\r
                          failure this parameter relays error contents.\r
\r
  @param[out]    Request  The pre-zeroed virtio-scsi request to populate. This\r
                          parameter is volatile-qualified because we expect the\r
                          caller to append it to a virtio ring, thus\r
                          assignments to Request must be visible when the\r
                          function returns.\r
\r
\r
  @retval EFI_SUCCESS  The Extended SCSI Pass Thru Protocol packet was valid,\r
                       Request has been populated.\r
\r
  @return              Otherwise, invalid or unsupported parameters were\r
                       detected. Status codes are meant for direct forwarding\r
                       by the EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru()\r
                       implementation.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
PopulateRequest (\r
  IN     CONST    VSCSI_DEV                                   *Dev,\r
  IN              UINT16                                      Target,\r
  IN              UINT64                                      Lun,\r
  IN OUT          EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet,\r
  OUT    volatile VIRTIO_SCSI_REQ                             *Request\r
  )\r
{\r
  UINTN Idx;\r
\r
  if (\r
      //\r
      // bidirectional transfer was requested, but the host doesn't support it\r
      //\r
      (Packet->InTransferLength > 0 && Packet->OutTransferLength > 0 &&\r
       !Dev->InOutSupported) ||\r
\r
      //\r
      // a target / LUN was addressed that's impossible to encode for the host\r
      //\r
      Target > 0xFF || Lun >= 0x4000 ||\r
\r
      //\r
      // Command Descriptor Block bigger than VIRTIO_SCSI_CDB_SIZE\r
      //\r
      Packet->CdbLength > VIRTIO_SCSI_CDB_SIZE ||\r
\r
      //\r
      // From virtio-0.9.5, 2.3.2 Descriptor Table:\r
      // "no descriptor chain may be more than 2^32 bytes long in total".\r
      //\r
      (UINT64) Packet->InTransferLength + Packet->OutTransferLength > SIZE_1GB\r
      ) {\r
\r
    //\r
    // this error code doesn't require updates to the Packet output fields\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (\r
      //\r
      // addressed invalid device\r
      //\r
      Target > Dev->MaxTarget || Lun > Dev->MaxLun ||\r
\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
      //\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
      //\r
      // trying to send, but source pointer is NULL, or contradicting transfer\r
      // 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
  // Catch oversized requests eagerly. If this condition evaluates to false,\r
  // then the combined size of a bidirectional request will not exceed the\r
  // virtio-scsi device's transfer limit either.\r
  //\r
  if (ALIGN_VALUE (Packet->OutTransferLength, 512) / 512\r
        > Dev->MaxSectors / 2 ||\r
      ALIGN_VALUE (Packet->InTransferLength,  512) / 512\r
        > Dev->MaxSectors / 2) {\r
    Packet->InTransferLength  = (Dev->MaxSectors / 2) * 512;\r
    Packet->OutTransferLength = (Dev->MaxSectors / 2) * 512;\r
    Packet->HostAdapterStatus =\r
                        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;\r
    Packet->TargetStatus      = EFI_EXT_SCSI_STATUS_TARGET_GOOD;\r
    Packet->SenseDataLength   = 0;\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  //\r
  // target & LUN encoding: see virtio-0.9.5, Appendix I: SCSI Host Device,\r
  // Device Operation: request queues\r
  //\r
  Request->Lun[0] = 1;\r
  Request->Lun[1] = (UINT8) Target;\r
  Request->Lun[2] = (UINT8) (((UINT32)Lun >> 8) | 0x40);\r
  Request->Lun[3] = (UINT8) Lun;\r
\r
  //\r
  // CopyMem() would cast away the "volatile" qualifier before access, which is\r
  // undefined behavior (ISO C99 6.7.3p5)\r
  //\r
  for (Idx = 0; Idx < Packet->CdbLength; ++Idx) {\r
    Request->Cdb[Idx] = ((UINT8 *) Packet->Cdb)[Idx];\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
\r
  Parse the virtio-scsi device's response, translate it to an EFI status code,\r
  and update the Extended SCSI Pass Thru Protocol packet, to be returned by\r
  the EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() implementation.\r
\r
  @param[in out] Packet  The Extended SCSI Pass Thru Protocol packet that has\r
                         been translated to a virtio-scsi request with\r
                         PopulateRequest(), and processed by the host. On\r
                         output this parameter is updated with response or\r
                         error contents.\r
\r
  @param[in] Response    The virtio-scsi response structure to parse. We expect\r
                         it to come from a virtio ring, thus it is qualified\r
                         volatile.\r
\r
\r
  @return  PassThru() status codes mandated by UEFI Spec 2.3.1 + Errata C, 14.7\r
           Extended SCSI Pass Thru Protocol.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
ParseResponse (\r
  IN OUT                EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,\r
  IN     CONST volatile VIRTIO_SCSI_RESP                           *Response\r
  )\r
{\r
  UINTN ResponseSenseLen;\r
  UINTN Idx;\r
\r
  //\r
  // return sense data (length and contents) in all cases, truncated if needed\r
  //\r
  ResponseSenseLen = MIN (Response->SenseLen, VIRTIO_SCSI_SENSE_SIZE);\r
  if (Packet->SenseDataLength > ResponseSenseLen) {\r
    Packet->SenseDataLength = (UINT8) ResponseSenseLen;\r
  }\r
  for (Idx = 0; Idx < Packet->SenseDataLength; ++Idx) {\r
    ((UINT8 *) Packet->SenseData)[Idx] = Response->Sense[Idx];\r
  }\r
\r
  //\r
  // Report actual transfer lengths. The logic below covers all three\r
  // DataDirections (read, write, bidirectional).\r
  //\r
  // -+- @ 0\r
  //  |\r
  //  | write                                       ^  @ Residual (unprocessed)\r
  //  |                                             |\r
  // -+- @ OutTransferLength                       -+- @ InTransferLength\r
  //  |                                             |\r
  //  | read                                        |\r
  //  |                                             |\r
  //  V  @ OutTransferLength + InTransferLength    -+- @ 0\r
  //\r
  if (Response->Residual <= Packet->InTransferLength) {\r
    Packet->InTransferLength  -= Response->Residual;\r
  }\r
  else {\r
    Packet->OutTransferLength -= Response->Residual - Packet->InTransferLength;\r
    Packet->InTransferLength   = 0;\r
  }\r
\r
  //\r
  // report target status in all cases\r
  //\r
  Packet->TargetStatus = Response->Status;\r
\r
  //\r
  // host adapter status and function return value depend on virtio-scsi\r
  // response code\r
  //\r
  switch (Response->Response) {\r
  case VIRTIO_SCSI_S_OK:\r
    Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK;\r
    return EFI_SUCCESS;\r
\r
  case VIRTIO_SCSI_S_OVERRUN:\r
    Packet->HostAdapterStatus =\r
                        EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;\r
    break;\r
\r
  case VIRTIO_SCSI_S_BAD_TARGET:\r
    //\r
    // This is non-intuitive but explicitly required by the\r
    // EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() specification for\r
    // disconnected (but otherwise valid) target / LUN addresses.\r
    //\r
    Packet->HostAdapterStatus =\r
                              EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND;\r
    return EFI_TIMEOUT;\r
\r
  case VIRTIO_SCSI_S_RESET:\r
    Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET;\r
    break;\r
\r
  case VIRTIO_SCSI_S_BUSY:\r
    Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK;\r
    return EFI_NOT_READY;\r
\r
  //\r
  // Lump together the rest. The mapping for VIRTIO_SCSI_S_ABORTED is\r
  // intentional as well, not an oversight.\r
  //\r
  case VIRTIO_SCSI_S_ABORTED:\r
  case VIRTIO_SCSI_S_TRANSPORT_FAILURE:\r
  case VIRTIO_SCSI_S_TARGET_FAILURE:\r
  case VIRTIO_SCSI_S_NEXUS_FAILURE:\r
  case VIRTIO_SCSI_S_FAILURE:\r
  default:\r
    Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;\r
  }\r
\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
\r
/**\r
\r
  The function can be used to create a fake host adapter error.\r
\r
  When VirtioScsiPassThru() is failed due to some reasons then this function\r
  can be called to construct a host adapter error.\r
\r
  @param[out] Packet  The Extended SCSI Pass Thru Protocol packet that the host\r
                      adapter error shall be placed in.\r
\r
\r
  @retval EFI_DEVICE_ERROR  The function returns this status code\r
                            unconditionally, to be propagated by\r
                            VirtioScsiPassThru().\r
\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->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;\r
  Packet->TargetStatus      = EFI_EXT_SCSI_STATUS_TARGET_GOOD;\r
  Packet->SenseDataLength   = 0;\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
\r
//\r
// The next seven functions implement EFI_EXT_SCSI_PASS_THRU_PROTOCOL\r
// for the virtio-scsi HBA. Refer to UEFI Spec 2.3.1 + Errata C, sections\r
// - 14.1 SCSI Driver Model Overview,\r
// - 14.7 Extended SCSI Pass Thru Protocol.\r
//\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiPassThru (\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
  VSCSI_DEV                 *Dev;\r
  UINT16                    TargetValue;\r
  EFI_STATUS                Status;\r
  volatile VIRTIO_SCSI_REQ  Request;\r
  volatile VIRTIO_SCSI_RESP *Response;\r
  VOID                      *ResponseBuffer;\r
  DESC_INDICES              Indices;\r
  VOID                      *RequestMapping;\r
  VOID                      *ResponseMapping;\r
  VOID                      *InDataMapping;\r
  VOID                      *OutDataMapping;\r
  EFI_PHYSICAL_ADDRESS      RequestDeviceAddress;\r
  EFI_PHYSICAL_ADDRESS      ResponseDeviceAddress;\r
  EFI_PHYSICAL_ADDRESS      InDataDeviceAddress;\r
  EFI_PHYSICAL_ADDRESS      OutDataDeviceAddress;\r
  VOID                      *InDataBuffer;\r
  UINTN                     InDataNumPages;\r
  BOOLEAN                   OutDataBufferIsMapped;\r
\r
  ZeroMem ((VOID*) &Request, sizeof (Request));\r
\r
  Dev = VIRTIO_SCSI_FROM_PASS_THRU (This);\r
  CopyMem (&TargetValue, Target, sizeof TargetValue);\r
\r
  InDataBuffer = NULL;\r
  OutDataBufferIsMapped = FALSE;\r
  InDataNumPages = 0;\r
\r
  Status = PopulateRequest (Dev, TargetValue, Lun, Packet, &Request);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Map the virtio-scsi Request header buffer\r
  //\r
  Status = VirtioMapAllBytesInSharedBuffer (\r
             Dev->VirtIo,\r
             VirtioOperationBusMasterRead,\r
             (VOID *) &Request,\r
             sizeof Request,\r
             &RequestDeviceAddress,\r
             &RequestMapping);\r
  if (EFI_ERROR (Status)) {\r
    return ReportHostAdapterError (Packet);\r
  }\r
\r
  //\r
  // Map the input buffer\r
  //\r
  if (Packet->InTransferLength > 0) {\r
    //\r
    // Allocate a intermediate input buffer. This is mainly to handle the\r
    // following case:\r
    //  * caller submits a bi-directional request\r
    //  * we perform the request fine\r
    //  * but we fail to unmap the "InDataMapping"\r
    //\r
    // In that case simply returing the EFI_DEVICE_ERROR is not sufficient. In\r
    // addition to the error code we also need to update Packet fields\r
    // accordingly so that we report the full loss of the incoming transfer.\r
    //\r
    // We allocate a temporary buffer and map it with BusMasterCommonBuffer. If\r
    // the Virtio request is successful then we copy the data from temporary\r
    // buffer into Packet->InDataBuffer.\r
    //\r
    InDataNumPages = EFI_SIZE_TO_PAGES ((UINTN)Packet->InTransferLength);\r
    Status = Dev->VirtIo->AllocateSharedPages (\r
                            Dev->VirtIo,\r
                            InDataNumPages,\r
                            &InDataBuffer\r
                            );\r
    if (EFI_ERROR (Status)) {\r
      Status = ReportHostAdapterError (Packet);\r
      goto UnmapRequestBuffer;\r
    }\r
\r
    ZeroMem (InDataBuffer, Packet->InTransferLength);\r
\r
    Status = VirtioMapAllBytesInSharedBuffer (\r
               Dev->VirtIo,\r
               VirtioOperationBusMasterCommonBuffer,\r
               InDataBuffer,\r
               Packet->InTransferLength,\r
               &InDataDeviceAddress,\r
               &InDataMapping\r
               );\r
    if (EFI_ERROR (Status)) {\r
      Status = ReportHostAdapterError (Packet);\r
      goto FreeInDataBuffer;\r
    }\r
  }\r
\r
  //\r
  // Map the output buffer\r
  //\r
  if (Packet->OutTransferLength > 0) {\r
    Status = VirtioMapAllBytesInSharedBuffer (\r
               Dev->VirtIo,\r
               VirtioOperationBusMasterRead,\r
               Packet->OutDataBuffer,\r
               Packet->OutTransferLength,\r
               &OutDataDeviceAddress,\r
               &OutDataMapping\r
               );\r
    if (EFI_ERROR (Status)) {\r
      Status = ReportHostAdapterError (Packet);\r
      goto UnmapInDataBuffer;\r
    }\r
\r
    OutDataBufferIsMapped = TRUE;\r
  }\r
\r
  //\r
  // Response header is bi-direction (we preset with host status and expect\r
  // the device to update it). Allocate a response buffer which can be mapped\r
  // to access equally by both processor and device.\r
  //\r
  Status = Dev->VirtIo->AllocateSharedPages (\r
                          Dev->VirtIo,\r
                          EFI_SIZE_TO_PAGES (sizeof *Response),\r
                          &ResponseBuffer\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    Status = ReportHostAdapterError (Packet);\r
    goto UnmapOutDataBuffer;\r
  }\r
\r
  Response = ResponseBuffer;\r
\r
  ZeroMem ((VOID *)Response, sizeof (*Response));\r
\r
  //\r
  // preset a host status for ourselves that we do not accept as success\r
  //\r
  Response->Response = VIRTIO_SCSI_S_FAILURE;\r
\r
  //\r
  // Map the response buffer with BusMasterCommonBuffer so that response\r
  // buffer can be accessed by both host and device.\r
  //\r
  Status = VirtioMapAllBytesInSharedBuffer (\r
             Dev->VirtIo,\r
             VirtioOperationBusMasterCommonBuffer,\r
             ResponseBuffer,\r
             sizeof (*Response),\r
             &ResponseDeviceAddress,\r
             &ResponseMapping\r
             );\r
  if (EFI_ERROR (Status)) {\r
    Status = ReportHostAdapterError (Packet);\r
    goto FreeResponseBuffer;\r
  }\r
\r
  VirtioPrepare (&Dev->Ring, &Indices);\r
\r
  //\r
  // ensured by VirtioScsiInit() -- this predicate, in combination with the\r
  // lock-step progress, ensures we don't have to track free descriptors.\r
  //\r
  ASSERT (Dev->Ring.QueueSize >= 4);\r
\r
  //\r
  // enqueue Request\r
  //\r
  VirtioAppendDesc (\r
    &Dev->Ring,\r
    RequestDeviceAddress,\r
    sizeof Request,\r
    VRING_DESC_F_NEXT,\r
    &Indices\r
    );\r
\r
  //\r
  // enqueue "dataout" if any\r
  //\r
  if (Packet->OutTransferLength > 0) {\r
    VirtioAppendDesc (\r
      &Dev->Ring,\r
      OutDataDeviceAddress,\r
      Packet->OutTransferLength,\r
      VRING_DESC_F_NEXT,\r
      &Indices\r
      );\r
  }\r
\r
  //\r
  // enqueue Response, to be written by the host\r
  //\r
  VirtioAppendDesc (\r
    &Dev->Ring,\r
    ResponseDeviceAddress,\r
    sizeof *Response,\r
    VRING_DESC_F_WRITE | (Packet->InTransferLength > 0 ? VRING_DESC_F_NEXT : 0),\r
    &Indices\r
    );\r
\r
  //\r
  // enqueue "datain" if any, to be written by the host\r
  //\r
  if (Packet->InTransferLength > 0) {\r
    VirtioAppendDesc (\r
      &Dev->Ring,\r
      InDataDeviceAddress,\r
      Packet->InTransferLength,\r
      VRING_DESC_F_WRITE,\r
      &Indices\r
      );\r
  }\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 the\r
  // caller retry.\r
  //\r
  if (VirtioFlush (Dev->VirtIo, VIRTIO_SCSI_REQUEST_QUEUE, &Dev->Ring,\r
        &Indices, NULL) != EFI_SUCCESS) {\r
    Status = ReportHostAdapterError (Packet);\r
    goto UnmapResponseBuffer;\r
  }\r
\r
  Status = ParseResponse (Packet, Response);\r
\r
  //\r
  // If virtio request was successful and it was a CPU read request then we\r
  // have used an intermediate buffer. Copy the data from intermediate buffer\r
  // to the final buffer.\r
  //\r
  if (InDataBuffer != NULL) {\r
    CopyMem (Packet->InDataBuffer, InDataBuffer, Packet->InTransferLength);\r
  }\r
\r
UnmapResponseBuffer:\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, ResponseMapping);\r
\r
FreeResponseBuffer:\r
  Dev->VirtIo->FreeSharedPages (\r
                 Dev->VirtIo,\r
                 EFI_SIZE_TO_PAGES (sizeof *Response),\r
                 ResponseBuffer\r
                 );\r
\r
UnmapOutDataBuffer:\r
  if (OutDataBufferIsMapped) {\r
    Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, OutDataMapping);\r
  }\r
\r
UnmapInDataBuffer:\r
  if (InDataBuffer != NULL) {\r
    Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, InDataMapping);\r
  }\r
\r
FreeInDataBuffer:\r
  if (InDataBuffer != NULL) {\r
    Dev->VirtIo->FreeSharedPages (Dev->VirtIo, InDataNumPages, InDataBuffer);\r
  }\r
\r
UnmapRequestBuffer:\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, RequestMapping);\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiGetNextTargetLun (\r
  IN     EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,\r
  IN OUT UINT8                           **TargetPointer,\r
  IN OUT UINT64                          *Lun\r
  )\r
{\r
  UINT8     *Target;\r
  UINTN     Idx;\r
  UINT16    LastTarget;\r
  VSCSI_DEV *Dev;\r
\r
  //\r
  // the TargetPointer input parameter is unnecessarily a pointer-to-pointer\r
  //\r
  Target = *TargetPointer;\r
\r
  //\r
  // Search for first non-0xFF byte. If not found, return first target & LUN.\r
  //\r
  for (Idx = 0; Idx < TARGET_MAX_BYTES && Target[Idx] == 0xFF; ++Idx)\r
    ;\r
  if (Idx == TARGET_MAX_BYTES) {\r
    SetMem (Target, TARGET_MAX_BYTES, 0x00);\r
    *Lun = 0;\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // see the TARGET_MAX_BYTES check in "VirtioScsi.h"\r
  //\r
  CopyMem (&LastTarget, Target, sizeof LastTarget);\r
\r
  //\r
  // increment (target, LUN) pair if valid on input\r
  //\r
  Dev = VIRTIO_SCSI_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
    CopyMem (Target, &LastTarget, sizeof LastTarget);\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiBuildDevicePath (\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
  UINT16           TargetValue;\r
  VSCSI_DEV        *Dev;\r
  SCSI_DEVICE_PATH *ScsiDevicePath;\r
\r
  if (DevicePath == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  CopyMem (&TargetValue, Target, sizeof TargetValue);\r
  Dev = VIRTIO_SCSI_FROM_PASS_THRU (This);\r
  if (TargetValue > Dev->MaxTarget || Lun > Dev->MaxLun || Lun > 0xFFFF) {\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
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiGetTargetLun (\r
  IN  EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,\r
  IN  EFI_DEVICE_PATH_PROTOCOL        *DevicePath,\r
  OUT UINT8                           **TargetPointer,\r
  OUT UINT64                          *Lun\r
  )\r
{\r
  SCSI_DEVICE_PATH *ScsiDevicePath;\r
  VSCSI_DEV        *Dev;\r
  UINT8            *Target;\r
\r
  if (DevicePath == NULL || TargetPointer == NULL || *TargetPointer == NULL ||\r
      Lun == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (DevicePath->Type    != MESSAGING_DEVICE_PATH ||\r
      DevicePath->SubType != MSG_SCSI_DP) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  ScsiDevicePath = (SCSI_DEVICE_PATH *) DevicePath;\r
  Dev = VIRTIO_SCSI_FROM_PASS_THRU (This);\r
  if (ScsiDevicePath->Pun > Dev->MaxTarget ||\r
      ScsiDevicePath->Lun > Dev->MaxLun) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // a) the TargetPointer input parameter is unnecessarily a pointer-to-pointer\r
  // b) see the TARGET_MAX_BYTES check in "VirtioScsi.h"\r
  // c) ScsiDevicePath->Pun is an UINT16\r
  //\r
  Target = *TargetPointer;\r
  CopyMem (Target, &ScsiDevicePath->Pun, 2);\r
  SetMem (Target + 2, TARGET_MAX_BYTES - 2, 0x00);\r
\r
  *Lun = ScsiDevicePath->Lun;\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiResetChannel (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiResetTargetLun (\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
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiGetNextTarget (\r
  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,\r
  IN OUT UINT8                       **TargetPointer\r
  )\r
{\r
  UINT8     *Target;\r
  UINTN     Idx;\r
  UINT16    LastTarget;\r
  VSCSI_DEV *Dev;\r
\r
  //\r
  // the TargetPointer input parameter is unnecessarily a pointer-to-pointer\r
  //\r
  Target = *TargetPointer;\r
\r
  //\r
  // Search for first non-0xFF byte. If not found, return first target.\r
  //\r
  for (Idx = 0; Idx < TARGET_MAX_BYTES && Target[Idx] == 0xFF; ++Idx)\r
    ;\r
  if (Idx == TARGET_MAX_BYTES) {\r
    SetMem (Target, TARGET_MAX_BYTES, 0x00);\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // see the TARGET_MAX_BYTES check in "VirtioScsi.h"\r
  //\r
  CopyMem (&LastTarget, Target, sizeof LastTarget);\r
\r
  //\r
  // increment target if valid on input\r
  //\r
  Dev = VIRTIO_SCSI_FROM_PASS_THRU (This);\r
  if (LastTarget > Dev->MaxTarget) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (LastTarget < Dev->MaxTarget) {\r
    ++LastTarget;\r
    CopyMem (Target, &LastTarget, sizeof LastTarget);\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiInit (\r
  IN OUT VSCSI_DEV *Dev\r
  )\r
{\r
  UINT8      NextDevStat;\r
  EFI_STATUS Status;\r
  UINT64     RingBaseShift;\r
  UINT64     Features;\r
  UINT16     MaxChannel; // for validation only\r
  UINT32     NumQueues;  // for validation only\r
  UINT16     QueueSize;\r
\r
  //\r
  // Execute virtio-0.9.5, 2.2.1 Device Initialization Sequence.\r
  //\r
  NextDevStat = 0;             // step 1 -- reset device\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
\r
  NextDevStat |= VSTAT_ACK;    // step 2 -- acknowledge device presence\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
\r
  NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
\r
  //\r
  // Set Page Size - MMIO VirtIo Specific\r
  //\r
  Status = Dev->VirtIo->SetPageSize (Dev->VirtIo, EFI_PAGE_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
\r
  //\r
  // step 4a -- retrieve and validate features\r
  //\r
  Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  Dev->InOutSupported = (BOOLEAN) ((Features & VIRTIO_SCSI_F_INOUT) != 0);\r
\r
  Status = VIRTIO_CFG_READ (Dev, MaxChannel, &MaxChannel);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  if (MaxChannel != 0) {\r
    //\r
    // this driver is for a single-channel virtio-scsi HBA\r
    //\r
    Status = EFI_UNSUPPORTED;\r
    goto Failed;\r
  }\r
\r
  Status = VIRTIO_CFG_READ (Dev, NumQueues, &NumQueues);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  if (NumQueues < 1) {\r
    Status = EFI_UNSUPPORTED;\r
    goto Failed;\r
  }\r
\r
  Status = VIRTIO_CFG_READ (Dev, MaxTarget, &Dev->MaxTarget);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  if (Dev->MaxTarget > PcdGet16 (PcdVirtioScsiMaxTargetLimit)) {\r
    Dev->MaxTarget = PcdGet16 (PcdVirtioScsiMaxTargetLimit);\r
  }\r
\r
  Status = VIRTIO_CFG_READ (Dev, MaxLun, &Dev->MaxLun);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  if (Dev->MaxLun > PcdGet32 (PcdVirtioScsiMaxLunLimit)) {\r
    Dev->MaxLun = PcdGet32 (PcdVirtioScsiMaxLunLimit);\r
  }\r
\r
  Status = VIRTIO_CFG_READ (Dev, MaxSectors, &Dev->MaxSectors);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  if (Dev->MaxSectors < 2) {\r
    //\r
    // We must be able to halve it for bidirectional transfers\r
    // (see EFI_BAD_BUFFER_SIZE in PopulateRequest()).\r
    //\r
    Status = EFI_UNSUPPORTED;\r
    goto Failed;\r
  }\r
\r
  Features &= VIRTIO_SCSI_F_INOUT | VIRTIO_F_VERSION_1 |\r
              VIRTIO_F_IOMMU_PLATFORM;\r
\r
  //\r
  // In virtio-1.0, feature negotiation is expected to complete before queue\r
  // discovery, and the device can also reject the selected set of features.\r
  //\r
  if (Dev->VirtIo->Revision >= VIRTIO_SPEC_REVISION (1, 0, 0)) {\r
    Status = Virtio10WriteFeatures (Dev->VirtIo, Features, &NextDevStat);\r
    if (EFI_ERROR (Status)) {\r
      goto Failed;\r
    }\r
  }\r
\r
  //\r
  // step 4b -- allocate request virtqueue\r
  //\r
  Status = Dev->VirtIo->SetQueueSel (Dev->VirtIo, VIRTIO_SCSI_REQUEST_QUEUE);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  Status = Dev->VirtIo->GetQueueNumMax (Dev->VirtIo, &QueueSize);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
  //\r
  // VirtioScsiPassThru() uses at most four descriptors\r
  //\r
  if (QueueSize < 4) {\r
    Status = EFI_UNSUPPORTED;\r
    goto Failed;\r
  }\r
\r
  Status = VirtioRingInit (Dev->VirtIo, QueueSize, &Dev->Ring);\r
  if (EFI_ERROR (Status)) {\r
    goto Failed;\r
  }\r
\r
  //\r
  // If anything fails from here on, we must release the ring resources\r
  //\r
  Status = VirtioRingMap (\r
             Dev->VirtIo,\r
             &Dev->Ring,\r
             &RingBaseShift,\r
             &Dev->RingMap\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseQueue;\r
  }\r
\r
  //\r
  // Additional steps for MMIO: align the queue appropriately, and set the\r
  // size. If anything fails from here on, we must unmap the ring resources.\r
  //\r
  Status = Dev->VirtIo->SetQueueNum (Dev->VirtIo, QueueSize);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  Status = Dev->VirtIo->SetQueueAlign (Dev->VirtIo, EFI_PAGE_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  //\r
  // step 4c -- Report GPFN (guest-physical frame number) of queue.\r
  //\r
  Status = Dev->VirtIo->SetQueueAddress (\r
                          Dev->VirtIo,\r
                          &Dev->Ring,\r
                          RingBaseShift\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  //\r
  // step 5 -- Report understood features and guest-tuneables.\r
  //\r
  if (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) {\r
    Features &= ~(UINT64)(VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM);\r
    Status = Dev->VirtIo->SetGuestFeatures (Dev->VirtIo, Features);\r
    if (EFI_ERROR (Status)) {\r
      goto UnmapQueue;\r
    }\r
  }\r
\r
  //\r
  // We expect these maximum sizes from the host. Since they are\r
  // guest-negotiable, ask for them rather than just checking them.\r
  //\r
  Status = VIRTIO_CFG_WRITE (Dev, CdbSize, VIRTIO_SCSI_CDB_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
  Status = VIRTIO_CFG_WRITE (Dev, SenseSize, VIRTIO_SCSI_SENSE_SIZE);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  //\r
  // step 6 -- initialization complete\r
  //\r
  NextDevStat |= VSTAT_DRIVER_OK;\r
  Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapQueue;\r
  }\r
\r
  //\r
  // populate the exported interface's attributes\r
  //\r
  Dev->PassThru.Mode             = &Dev->PassThruMode;\r
  Dev->PassThru.PassThru         = &VirtioScsiPassThru;\r
  Dev->PassThru.GetNextTargetLun = &VirtioScsiGetNextTargetLun;\r
  Dev->PassThru.BuildDevicePath  = &VirtioScsiBuildDevicePath;\r
  Dev->PassThru.GetTargetLun     = &VirtioScsiGetTargetLun;\r
  Dev->PassThru.ResetChannel     = &VirtioScsiResetChannel;\r
  Dev->PassThru.ResetTargetLun   = &VirtioScsiResetTargetLun;\r
  Dev->PassThru.GetNextTarget    = &VirtioScsiGetNextTarget;\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 = 0xFFFFFFFF;\r
\r
  //\r
  // Set both physical and logical attributes for non-RAID SCSI channel. See\r
  // Driver Writer's Guide for UEFI 2.3.1 v1.01, 20.1.5 Implementing Extended\r
  // SCSI Pass Thru Protocol.\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
UnmapQueue:\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);\r
\r
ReleaseQueue:\r
  VirtioRingUninit (Dev->VirtIo, &Dev->Ring);\r
\r
Failed:\r
  //\r
  // Notify the host about our failure to setup: virtio-0.9.5, 2.2.2.1 Device\r
  // Status. VirtIo access failure here should not mask the original error.\r
  //\r
  NextDevStat |= VSTAT_FAILED;\r
  Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);\r
\r
  Dev->InOutSupported = FALSE;\r
  Dev->MaxTarget      = 0;\r
  Dev->MaxLun         = 0;\r
  Dev->MaxSectors     = 0;\r
\r
  return Status; // reached only via Failed above\r
}\r
\r
\r
STATIC\r
VOID\r
EFIAPI\r
VirtioScsiUninit (\r
  IN OUT VSCSI_DEV *Dev\r
  )\r
{\r
  //\r
  // Reset the virtual device -- see virtio-0.9.5, 2.2.2.1 Device Status. When\r
  // VIRTIO_CFG_WRITE() returns, the host will have learned to stay away from\r
  // the old comms area.\r
  //\r
  Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);\r
\r
  Dev->InOutSupported = FALSE;\r
  Dev->MaxTarget      = 0;\r
  Dev->MaxLun         = 0;\r
  Dev->MaxSectors     = 0;\r
\r
  Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);\r
  VirtioRingUninit (Dev->VirtIo, &Dev->Ring);\r
\r
  SetMem (&Dev->PassThru,     sizeof Dev->PassThru,     0x00);\r
  SetMem (&Dev->PassThruMode, sizeof Dev->PassThruMode, 0x00);\r
}\r
\r
\r
//\r
// Event notification function enqueued by ExitBootServices().\r
//\r
\r
STATIC\r
VOID\r
EFIAPI\r
VirtioScsiExitBoot (\r
  IN  EFI_EVENT Event,\r
  IN  VOID      *Context\r
  )\r
{\r
  VSCSI_DEV *Dev;\r
\r
  DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));\r
  //\r
  // Reset the device. This causes the hypervisor to forget about the virtio\r
  // ring.\r
  //\r
  // We allocated said ring in EfiBootServicesData type memory, and code\r
  // executing after ExitBootServices() is permitted to overwrite it.\r
  //\r
  Dev = Context;\r
  Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);\r
}\r
\r
\r
//\r
// Probe, start and stop functions of this driver, called by the DXE core for\r
// specific devices.\r
//\r
// The following specifications document these interfaces:\r
// - Driver Writer's Guide for UEFI 2.3.1 v1.01, 9 Driver Binding Protocol\r
// - UEFI Spec 2.3.1 + Errata C, 10.1 EFI Driver Binding Protocol\r
//\r
// The implementation follows:\r
// - Driver Writer's Guide for UEFI 2.3.1 v1.01\r
//   - 5.1.3.4 OpenProtocol() and CloseProtocol()\r
// - UEFI Spec 2.3.1 + Errata C\r
//   -  6.3 Protocol Handler Services\r
//\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
  IN EFI_HANDLE                  DeviceHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS             Status;\r
  VIRTIO_DEVICE_PROTOCOL *VirtIo;\r
\r
  //\r
  // Attempt to open the device with the VirtIo set of interfaces. On success,\r
  // the protocol is "instantiated" for the VirtIo device. Covers duplicate open\r
  // attempts (EFI_ALREADY_STARTED).\r
  //\r
  Status = gBS->OpenProtocol (\r
                  DeviceHandle,               // candidate device\r
                  &gVirtioDeviceProtocolGuid, // for generic VirtIo access\r
                  (VOID **)&VirtIo,           // handle to instantiate\r
                  This->DriverBindingHandle,  // requestor driver identity\r
                  DeviceHandle,               // ControllerHandle, according to\r
                                              // the UEFI Driver Model\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive VirtIo access to\r
                                              // the device; to be released\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (VirtIo->SubSystemDeviceId != VIRTIO_SUBSYSTEM_SCSI_HOST) {\r
    Status = EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // We needed VirtIo access only transitorily, to see whether we support the\r
  // device or not.\r
  //\r
  gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,\r
         This->DriverBindingHandle, DeviceHandle);\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
  IN EFI_HANDLE                  DeviceHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath\r
  )\r
{\r
  VSCSI_DEV  *Dev;\r
  EFI_STATUS Status;\r
\r
  Dev = (VSCSI_DEV *) AllocateZeroPool (sizeof *Dev);\r
  if (Dev == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,\r
                  (VOID **)&Dev->VirtIo, This->DriverBindingHandle,\r
                  DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);\r
  if (EFI_ERROR (Status)) {\r
    goto FreeVirtioScsi;\r
  }\r
\r
  //\r
  // VirtIo access granted, configure virtio-scsi device.\r
  //\r
  Status = VirtioScsiInit (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto CloseVirtIo;\r
  }\r
\r
  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK,\r
                  &VirtioScsiExitBoot, Dev, &Dev->ExitBoot);\r
  if (EFI_ERROR (Status)) {\r
    goto UninitDev;\r
  }\r
\r
  //\r
  // Setup complete, attempt to export the driver instance's PassThru\r
  // interface.\r
  //\r
  Dev->Signature = VSCSI_SIG;\r
  Status = gBS->InstallProtocolInterface (&DeviceHandle,\r
                  &gEfiExtScsiPassThruProtocolGuid, EFI_NATIVE_INTERFACE,\r
                  &Dev->PassThru);\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
  VirtioScsiUninit (Dev);\r
\r
CloseVirtIo:\r
  gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,\r
         This->DriverBindingHandle, DeviceHandle);\r
\r
FreeVirtioScsi:\r
  FreePool (Dev);\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiDriverBindingStop (\r
  IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
  IN EFI_HANDLE                  DeviceHandle,\r
  IN UINTN                       NumberOfChildren,\r
  IN EFI_HANDLE                  *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_EXT_SCSI_PASS_THRU_PROTOCOL *PassThru;\r
  VSCSI_DEV                       *Dev;\r
\r
  Status = gBS->OpenProtocol (\r
                  DeviceHandle,                     // candidate device\r
                  &gEfiExtScsiPassThruProtocolGuid, // retrieve the SCSI iface\r
                  (VOID **)&PassThru,               // target pointer\r
                  This->DriverBindingHandle,        // requestor driver ident.\r
                  DeviceHandle,                     // lookup req. for dev.\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL    // lookup only, no new ref.\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Dev = VIRTIO_SCSI_FROM_PASS_THRU (PassThru);\r
\r
  //\r
  // Handle Stop() requests for in-use driver instances gracefully.\r
  //\r
  Status = gBS->UninstallProtocolInterface (DeviceHandle,\r
                  &gEfiExtScsiPassThruProtocolGuid, &Dev->PassThru);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  gBS->CloseEvent (Dev->ExitBoot);\r
\r
  VirtioScsiUninit (Dev);\r
\r
  gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,\r
         This->DriverBindingHandle, DeviceHandle);\r
\r
  FreePool (Dev);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
//\r
// The static object that groups the Supported() (ie. probe), Start() and\r
// Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata\r
// C, 10.1 EFI Driver Binding Protocol.\r
//\r
STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {\r
  &VirtioScsiDriverBindingSupported,\r
  &VirtioScsiDriverBindingStart,\r
  &VirtioScsiDriverBindingStop,\r
  0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers\r
  NULL, // ImageHandle, to be overwritten by\r
        // EfiLibInstallDriverBindingComponentName2() in VirtioScsiEntryPoint()\r
  NULL  // DriverBindingHandle, ditto\r
};\r
\r
\r
//\r
// The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and\r
// EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name\r
// in English, for display on standard console devices. This is recommended for\r
// UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's\r
// Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.\r
//\r
// Device type names ("Virtio SCSI Host Device") are not formatted because the\r
// driver supports only that device type. Therefore the driver name suffices\r
// for unambiguous identification.\r
//\r
\r
STATIC\r
EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {\r
  { "eng;en", L"Virtio SCSI Host Driver" },\r
  { NULL,     NULL                   }\r
};\r
\r
STATIC\r
EFI_COMPONENT_NAME_PROTOCOL gComponentName;\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiGetDriverName (\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 == &gComponentName) // Iso639Language\r
           );\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiGetDeviceName (\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\r
EFI_COMPONENT_NAME_PROTOCOL gComponentName = {\r
  &VirtioScsiGetDriverName,\r
  &VirtioScsiGetDeviceName,\r
  "eng" // SupportedLanguages, ISO 639-2 language codes\r
};\r
\r
STATIC\r
EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {\r
  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)     &VirtioScsiGetDriverName,\r
  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &VirtioScsiGetDeviceName,\r
  "en" // SupportedLanguages, RFC 4646 language codes\r
};\r
\r
\r
//\r
// Entry point of this driver.\r
//\r
EFI_STATUS\r
EFIAPI\r
VirtioScsiEntryPoint (\r
  IN EFI_HANDLE       ImageHandle,\r
  IN EFI_SYSTEM_TABLE *SystemTable\r
  )\r
{\r
  return EfiLibInstallDriverBindingComponentName2 (\r
           ImageHandle,\r
           SystemTable,\r
           &gDriverBinding,\r
           ImageHandle,\r
           &gComponentName,\r
           &gComponentName2\r
           );\r
}\r