Google Git
Sign in
qemu / edk2 / refs/heads/9m11_23 / . / OvmfPkg / VirtioScsiDxe / VirtioScsi.c
blob: 3705f5fc14d56880547922c1899e74d2653bf6fe [file] [log] [blame]
/** @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
);
}