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