3 This driver produces Extended SCSI Pass Thru Protocol instances for
6 The implementation is basic:
8 - No hotplug / hot-unplug.
10 - Although EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() could be a good match
11 for multiple in-flight virtio-scsi requests, we stick to synchronous
14 - Timeouts are not supported for EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru().
16 - Only one channel is supported. (At the time of this writing, host-side
17 virtio-scsi supports a single channel too.)
19 - Only one request queue is used (for the one synchronous request).
21 - The ResetChannel() and ResetTargetLun() functions of
22 EFI_EXT_SCSI_PASS_THRU_PROTOCOL are not supported (which is allowed by the
23 UEFI 2.3.1 Errata C specification), although
24 VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET could be a good match. That would
25 however require client code for the control queue, which is deemed
28 Copyright (C) 2012, Red Hat, Inc.
29 Copyright (c) 2012 - 2014, Intel Corporation. All rights reserved.<BR>
30 Copyright (c) 2017, AMD Inc, All rights reserved.<BR>
32 This program and the accompanying materials are licensed and made available
33 under the terms and conditions of the BSD License which accompanies this
34 distribution. The full text of the license may be found at
35 http://opensource.org/licenses/bsd-license.php
37 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
38 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
42 #include <IndustryStandard/VirtioScsi.h>
43 #include <Library/BaseMemoryLib.h>
44 #include <Library/DebugLib.h>
45 #include <Library/MemoryAllocationLib.h>
46 #include <Library/UefiBootServicesTableLib.h>
47 #include <Library/UefiLib.h>
48 #include <Library/VirtioLib.h>
50 #include "VirtioScsi.h"
54 Convenience macros to read and write configuration elements of the
55 virtio-scsi VirtIo device.
57 The following macros make it possible to specify only the "core parameters"
58 for such accesses and to derive the rest. By the time VIRTIO_CFG_WRITE()
59 returns, the transaction will have been completed.
61 @param[in] Dev Pointer to the VSCSI_DEV structure.
63 @param[in] Field A field name from VSCSI_HDR, identifying the virtio-scsi
64 configuration item to access.
66 @param[in] Value (VIRTIO_CFG_WRITE() only.) The value to write to the
67 selected configuration item.
69 @param[out] Pointer (VIRTIO_CFG_READ() only.) The object to receive the
70 value read from the configuration item. Its type must be
71 one of UINT8, UINT16, UINT32, UINT64.
74 @return Status codes returned by Virtio->WriteDevice() / Virtio->ReadDevice().
78 #define VIRTIO_CFG_WRITE(Dev, Field, Value) ((Dev)->VirtIo->WriteDevice ( \
80 OFFSET_OF_VSCSI (Field), \
81 SIZE_OF_VSCSI (Field), \
85 #define VIRTIO_CFG_READ(Dev, Field, Pointer) ((Dev)->VirtIo->ReadDevice ( \
87 OFFSET_OF_VSCSI (Field), \
88 SIZE_OF_VSCSI (Field), \
95 // UEFI Spec 2.3.1 + Errata C, 14.7 Extended SCSI Pass Thru Protocol specifies
96 // the PassThru() interface. Beside returning a status code, the function must
97 // set some fields in the EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET in/out
98 // parameter on return. The following is a full list of those fields, for
99 // easier validation of PopulateRequest(), ParseResponse(), and
100 // VirtioScsiPassThru() below.
102 // - InTransferLength
103 // - OutTransferLength
104 // - HostAdapterStatus
109 // On any return from the PassThru() interface, these fields must be set,
110 // except if the returned status code is explicitly exempt. (Actually the
111 // implementation here conservatively sets these fields even in case not all
112 // of them would be required by the specification.)
117 Populate a virtio-scsi request from the Extended SCSI Pass Thru Protocol
120 The caller is responsible for pre-zeroing the virtio-scsi request. The
121 Extended SCSI Pass Thru Protocol packet is modified, to be forwarded outwards
122 by VirtioScsiPassThru(), if invalid or unsupported parameters are detected.
124 @param[in] Dev The virtio-scsi host device the packet targets.
126 @param[in] Target The SCSI target controlled by the virtio-scsi host
129 @param[in] Lun The Logical Unit Number under the SCSI target.
131 @param[in out] Packet The Extended SCSI Pass Thru Protocol packet the
132 function translates to a virtio-scsi request. On
133 failure this parameter relays error contents.
135 @param[out] Request The pre-zeroed virtio-scsi request to populate. This
136 parameter is volatile-qualified because we expect the
137 caller to append it to a virtio ring, thus
138 assignments to Request must be visible when the
142 @retval EFI_SUCCESS The Extended SCSI Pass Thru Protocol packet was valid,
143 Request has been populated.
145 @return Otherwise, invalid or unsupported parameters were
146 detected. Status codes are meant for direct forwarding
147 by the EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru()
155 IN CONST VSCSI_DEV
*Dev
,
158 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
*Packet
,
159 OUT
volatile VIRTIO_SCSI_REQ
*Request
166 // bidirectional transfer was requested, but the host doesn't support it
168 (Packet
->InTransferLength
> 0 && Packet
->OutTransferLength
> 0 &&
169 !Dev
->InOutSupported
) ||
172 // a target / LUN was addressed that's impossible to encode for the host
174 Target
> 0xFF || Lun
>= 0x4000 ||
177 // Command Descriptor Block bigger than VIRTIO_SCSI_CDB_SIZE
179 Packet
->CdbLength
> VIRTIO_SCSI_CDB_SIZE
||
182 // From virtio-0.9.5, 2.3.2 Descriptor Table:
183 // "no descriptor chain may be more than 2^32 bytes long in total".
185 (UINT64
) Packet
->InTransferLength
+ Packet
->OutTransferLength
> SIZE_1GB
189 // this error code doesn't require updates to the Packet output fields
191 return EFI_UNSUPPORTED
;
196 // addressed invalid device
198 Target
> Dev
->MaxTarget
|| Lun
> Dev
->MaxLun
||
201 // invalid direction (there doesn't seem to be a macro for the "no data
202 // transferred" "direction", eg. for TEST UNIT READY)
204 Packet
->DataDirection
> EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL
||
207 // trying to receive, but destination pointer is NULL, or contradicting
208 // transfer direction
210 (Packet
->InTransferLength
> 0 &&
211 (Packet
->InDataBuffer
== NULL
||
212 Packet
->DataDirection
== EFI_EXT_SCSI_DATA_DIRECTION_WRITE
217 // trying to send, but source pointer is NULL, or contradicting transfer
220 (Packet
->OutTransferLength
> 0 &&
221 (Packet
->OutDataBuffer
== NULL
||
222 Packet
->DataDirection
== EFI_EXT_SCSI_DATA_DIRECTION_READ
228 // this error code doesn't require updates to the Packet output fields
230 return EFI_INVALID_PARAMETER
;
234 // Catch oversized requests eagerly. If this condition evaluates to false,
235 // then the combined size of a bidirectional request will not exceed the
236 // virtio-scsi device's transfer limit either.
238 if (ALIGN_VALUE (Packet
->OutTransferLength
, 512) / 512
239 > Dev
->MaxSectors
/ 2 ||
240 ALIGN_VALUE (Packet
->InTransferLength
, 512) / 512
241 > Dev
->MaxSectors
/ 2) {
242 Packet
->InTransferLength
= (Dev
->MaxSectors
/ 2) * 512;
243 Packet
->OutTransferLength
= (Dev
->MaxSectors
/ 2) * 512;
244 Packet
->HostAdapterStatus
=
245 EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN
;
246 Packet
->TargetStatus
= EFI_EXT_SCSI_STATUS_TARGET_GOOD
;
247 Packet
->SenseDataLength
= 0;
248 return EFI_BAD_BUFFER_SIZE
;
252 // target & LUN encoding: see virtio-0.9.5, Appendix I: SCSI Host Device,
253 // Device Operation: request queues
256 Request
->Lun
[1] = (UINT8
) Target
;
257 Request
->Lun
[2] = (UINT8
) (((UINT32
)Lun
>> 8) | 0x40);
258 Request
->Lun
[3] = (UINT8
) Lun
;
261 // CopyMem() would cast away the "volatile" qualifier before access, which is
262 // undefined behavior (ISO C99 6.7.3p5)
264 for (Idx
= 0; Idx
< Packet
->CdbLength
; ++Idx
) {
265 Request
->Cdb
[Idx
] = ((UINT8
*) Packet
->Cdb
)[Idx
];
274 Parse the virtio-scsi device's response, translate it to an EFI status code,
275 and update the Extended SCSI Pass Thru Protocol packet, to be returned by
276 the EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() implementation.
278 @param[in out] Packet The Extended SCSI Pass Thru Protocol packet that has
279 been translated to a virtio-scsi request with
280 PopulateRequest(), and processed by the host. On
281 output this parameter is updated with response or
284 @param[in] Response The virtio-scsi response structure to parse. We expect
285 it to come from a virtio ring, thus it is qualified
289 @return PassThru() status codes mandated by UEFI Spec 2.3.1 + Errata C, 14.7
290 Extended SCSI Pass Thru Protocol.
297 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
*Packet
,
298 IN CONST
volatile VIRTIO_SCSI_RESP
*Response
301 UINTN ResponseSenseLen
;
305 // return sense data (length and contents) in all cases, truncated if needed
307 ResponseSenseLen
= MIN (Response
->SenseLen
, VIRTIO_SCSI_SENSE_SIZE
);
308 if (Packet
->SenseDataLength
> ResponseSenseLen
) {
309 Packet
->SenseDataLength
= (UINT8
) ResponseSenseLen
;
311 for (Idx
= 0; Idx
< Packet
->SenseDataLength
; ++Idx
) {
312 ((UINT8
*) Packet
->SenseData
)[Idx
] = Response
->Sense
[Idx
];
316 // Report actual transfer lengths. The logic below covers all three
317 // DataDirections (read, write, bidirectional).
321 // | write ^ @ Residual (unprocessed)
323 // -+- @ OutTransferLength -+- @ InTransferLength
327 // V @ OutTransferLength + InTransferLength -+- @ 0
329 if (Response
->Residual
<= Packet
->InTransferLength
) {
330 Packet
->InTransferLength
-= Response
->Residual
;
333 Packet
->OutTransferLength
-= Response
->Residual
- Packet
->InTransferLength
;
334 Packet
->InTransferLength
= 0;
338 // report target status in all cases
340 Packet
->TargetStatus
= Response
->Status
;
343 // host adapter status and function return value depend on virtio-scsi
346 switch (Response
->Response
) {
347 case VIRTIO_SCSI_S_OK
:
348 Packet
->HostAdapterStatus
= EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK
;
351 case VIRTIO_SCSI_S_OVERRUN
:
352 Packet
->HostAdapterStatus
=
353 EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN
;
356 case VIRTIO_SCSI_S_BAD_TARGET
:
358 // This is non-intuitive but explicitly required by the
359 // EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() specification for
360 // disconnected (but otherwise valid) target / LUN addresses.
362 Packet
->HostAdapterStatus
=
363 EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND
;
366 case VIRTIO_SCSI_S_RESET
:
367 Packet
->HostAdapterStatus
= EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET
;
370 case VIRTIO_SCSI_S_BUSY
:
371 Packet
->HostAdapterStatus
= EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK
;
372 return EFI_NOT_READY
;
375 // Lump together the rest. The mapping for VIRTIO_SCSI_S_ABORTED is
376 // intentional as well, not an oversight.
378 case VIRTIO_SCSI_S_ABORTED
:
379 case VIRTIO_SCSI_S_TRANSPORT_FAILURE
:
380 case VIRTIO_SCSI_S_TARGET_FAILURE
:
381 case VIRTIO_SCSI_S_NEXUS_FAILURE
:
382 case VIRTIO_SCSI_S_FAILURE
:
384 Packet
->HostAdapterStatus
= EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER
;
387 return EFI_DEVICE_ERROR
;
392 // The next seven functions implement EFI_EXT_SCSI_PASS_THRU_PROTOCOL
393 // for the virtio-scsi HBA. Refer to UEFI Spec 2.3.1 + Errata C, sections
394 // - 14.1 SCSI Driver Model Overview,
395 // - 14.7 Extended SCSI Pass Thru Protocol.
401 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
404 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
*Packet
,
405 IN EFI_EVENT Event OPTIONAL
411 volatile VIRTIO_SCSI_REQ Request
;
412 volatile VIRTIO_SCSI_RESP Response
;
413 DESC_INDICES Indices
;
415 ZeroMem ((VOID
*) &Request
, sizeof (Request
));
416 ZeroMem ((VOID
*) &Response
, sizeof (Response
));
418 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (This
);
419 CopyMem (&TargetValue
, Target
, sizeof TargetValue
);
421 Status
= PopulateRequest (Dev
, TargetValue
, Lun
, Packet
, &Request
);
422 if (EFI_ERROR (Status
)) {
426 VirtioPrepare (&Dev
->Ring
, &Indices
);
429 // preset a host status for ourselves that we do not accept as success
431 Response
.Response
= VIRTIO_SCSI_S_FAILURE
;
434 // ensured by VirtioScsiInit() -- this predicate, in combination with the
435 // lock-step progress, ensures we don't have to track free descriptors.
437 ASSERT (Dev
->Ring
.QueueSize
>= 4);
442 VirtioAppendDesc (&Dev
->Ring
, (UINTN
) &Request
, sizeof Request
,
443 VRING_DESC_F_NEXT
, &Indices
);
446 // enqueue "dataout" if any
448 if (Packet
->OutTransferLength
> 0) {
449 VirtioAppendDesc (&Dev
->Ring
, (UINTN
) Packet
->OutDataBuffer
,
450 Packet
->OutTransferLength
, VRING_DESC_F_NEXT
, &Indices
);
454 // enqueue Response, to be written by the host
456 VirtioAppendDesc (&Dev
->Ring
, (UINTN
) &Response
, sizeof Response
,
457 VRING_DESC_F_WRITE
| (Packet
->InTransferLength
> 0 ?
458 VRING_DESC_F_NEXT
: 0),
462 // enqueue "datain" if any, to be written by the host
464 if (Packet
->InTransferLength
> 0) {
465 VirtioAppendDesc (&Dev
->Ring
, (UINTN
) Packet
->InDataBuffer
,
466 Packet
->InTransferLength
, VRING_DESC_F_WRITE
, &Indices
);
469 // If kicking the host fails, we must fake a host adapter error.
470 // EFI_NOT_READY would save us the effort, but it would also suggest that the
473 if (VirtioFlush (Dev
->VirtIo
, VIRTIO_SCSI_REQUEST_QUEUE
, &Dev
->Ring
,
474 &Indices
, NULL
) != EFI_SUCCESS
) {
475 Packet
->InTransferLength
= 0;
476 Packet
->OutTransferLength
= 0;
477 Packet
->HostAdapterStatus
= EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER
;
478 Packet
->TargetStatus
= EFI_EXT_SCSI_STATUS_TARGET_GOOD
;
479 Packet
->SenseDataLength
= 0;
480 return EFI_DEVICE_ERROR
;
483 return ParseResponse (Packet
, &Response
);
489 VirtioScsiGetNextTargetLun (
490 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
491 IN OUT UINT8
**TargetPointer
,
501 // the TargetPointer input parameter is unnecessarily a pointer-to-pointer
503 Target
= *TargetPointer
;
506 // Search for first non-0xFF byte. If not found, return first target & LUN.
508 for (Idx
= 0; Idx
< TARGET_MAX_BYTES
&& Target
[Idx
] == 0xFF; ++Idx
)
510 if (Idx
== TARGET_MAX_BYTES
) {
511 SetMem (Target
, TARGET_MAX_BYTES
, 0x00);
517 // see the TARGET_MAX_BYTES check in "VirtioScsi.h"
519 CopyMem (&LastTarget
, Target
, sizeof LastTarget
);
522 // increment (target, LUN) pair if valid on input
524 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (This
);
525 if (LastTarget
> Dev
->MaxTarget
|| *Lun
> Dev
->MaxLun
) {
526 return EFI_INVALID_PARAMETER
;
529 if (*Lun
< Dev
->MaxLun
) {
534 if (LastTarget
< Dev
->MaxTarget
) {
537 CopyMem (Target
, &LastTarget
, sizeof LastTarget
);
541 return EFI_NOT_FOUND
;
547 VirtioScsiBuildDevicePath (
548 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
551 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
556 SCSI_DEVICE_PATH
*ScsiDevicePath
;
558 if (DevicePath
== NULL
) {
559 return EFI_INVALID_PARAMETER
;
562 CopyMem (&TargetValue
, Target
, sizeof TargetValue
);
563 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (This
);
564 if (TargetValue
> Dev
->MaxTarget
|| Lun
> Dev
->MaxLun
|| Lun
> 0xFFFF) {
565 return EFI_NOT_FOUND
;
568 ScsiDevicePath
= AllocatePool (sizeof *ScsiDevicePath
);
569 if (ScsiDevicePath
== NULL
) {
570 return EFI_OUT_OF_RESOURCES
;
573 ScsiDevicePath
->Header
.Type
= MESSAGING_DEVICE_PATH
;
574 ScsiDevicePath
->Header
.SubType
= MSG_SCSI_DP
;
575 ScsiDevicePath
->Header
.Length
[0] = (UINT8
) sizeof *ScsiDevicePath
;
576 ScsiDevicePath
->Header
.Length
[1] = (UINT8
) (sizeof *ScsiDevicePath
>> 8);
577 ScsiDevicePath
->Pun
= TargetValue
;
578 ScsiDevicePath
->Lun
= (UINT16
) Lun
;
580 *DevicePath
= &ScsiDevicePath
->Header
;
587 VirtioScsiGetTargetLun (
588 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
589 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
590 OUT UINT8
**TargetPointer
,
594 SCSI_DEVICE_PATH
*ScsiDevicePath
;
598 if (DevicePath
== NULL
|| TargetPointer
== NULL
|| *TargetPointer
== NULL
||
600 return EFI_INVALID_PARAMETER
;
603 if (DevicePath
->Type
!= MESSAGING_DEVICE_PATH
||
604 DevicePath
->SubType
!= MSG_SCSI_DP
) {
605 return EFI_UNSUPPORTED
;
608 ScsiDevicePath
= (SCSI_DEVICE_PATH
*) DevicePath
;
609 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (This
);
610 if (ScsiDevicePath
->Pun
> Dev
->MaxTarget
||
611 ScsiDevicePath
->Lun
> Dev
->MaxLun
) {
612 return EFI_NOT_FOUND
;
616 // a) the TargetPointer input parameter is unnecessarily a pointer-to-pointer
617 // b) see the TARGET_MAX_BYTES check in "VirtioScsi.h"
618 // c) ScsiDevicePath->Pun is an UINT16
620 Target
= *TargetPointer
;
621 CopyMem (Target
, &ScsiDevicePath
->Pun
, 2);
622 SetMem (Target
+ 2, TARGET_MAX_BYTES
- 2, 0x00);
624 *Lun
= ScsiDevicePath
->Lun
;
631 VirtioScsiResetChannel (
632 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
635 return EFI_UNSUPPORTED
;
641 VirtioScsiResetTargetLun (
642 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
647 return EFI_UNSUPPORTED
;
653 VirtioScsiGetNextTarget (
654 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*This
,
655 IN OUT UINT8
**TargetPointer
664 // the TargetPointer input parameter is unnecessarily a pointer-to-pointer
666 Target
= *TargetPointer
;
669 // Search for first non-0xFF byte. If not found, return first target.
671 for (Idx
= 0; Idx
< TARGET_MAX_BYTES
&& Target
[Idx
] == 0xFF; ++Idx
)
673 if (Idx
== TARGET_MAX_BYTES
) {
674 SetMem (Target
, TARGET_MAX_BYTES
, 0x00);
679 // see the TARGET_MAX_BYTES check in "VirtioScsi.h"
681 CopyMem (&LastTarget
, Target
, sizeof LastTarget
);
684 // increment target if valid on input
686 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (This
);
687 if (LastTarget
> Dev
->MaxTarget
) {
688 return EFI_INVALID_PARAMETER
;
691 if (LastTarget
< Dev
->MaxTarget
) {
693 CopyMem (Target
, &LastTarget
, sizeof LastTarget
);
697 return EFI_NOT_FOUND
;
705 IN OUT VSCSI_DEV
*Dev
710 UINT64 RingBaseShift
;
712 UINT16 MaxChannel
; // for validation only
713 UINT32 NumQueues
; // for validation only
717 // Execute virtio-0.9.5, 2.2.1 Device Initialization Sequence.
719 NextDevStat
= 0; // step 1 -- reset device
720 Status
= Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, NextDevStat
);
721 if (EFI_ERROR (Status
)) {
725 NextDevStat
|= VSTAT_ACK
; // step 2 -- acknowledge device presence
726 Status
= Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, NextDevStat
);
727 if (EFI_ERROR (Status
)) {
731 NextDevStat
|= VSTAT_DRIVER
; // step 3 -- we know how to drive it
732 Status
= Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, NextDevStat
);
733 if (EFI_ERROR (Status
)) {
738 // Set Page Size - MMIO VirtIo Specific
740 Status
= Dev
->VirtIo
->SetPageSize (Dev
->VirtIo
, EFI_PAGE_SIZE
);
741 if (EFI_ERROR (Status
)) {
746 // step 4a -- retrieve and validate features
748 Status
= Dev
->VirtIo
->GetDeviceFeatures (Dev
->VirtIo
, &Features
);
749 if (EFI_ERROR (Status
)) {
752 Dev
->InOutSupported
= (BOOLEAN
) ((Features
& VIRTIO_SCSI_F_INOUT
) != 0);
754 Status
= VIRTIO_CFG_READ (Dev
, MaxChannel
, &MaxChannel
);
755 if (EFI_ERROR (Status
)) {
758 if (MaxChannel
!= 0) {
760 // this driver is for a single-channel virtio-scsi HBA
762 Status
= EFI_UNSUPPORTED
;
766 Status
= VIRTIO_CFG_READ (Dev
, NumQueues
, &NumQueues
);
767 if (EFI_ERROR (Status
)) {
771 Status
= EFI_UNSUPPORTED
;
775 Status
= VIRTIO_CFG_READ (Dev
, MaxTarget
, &Dev
->MaxTarget
);
776 if (EFI_ERROR (Status
)) {
779 if (Dev
->MaxTarget
> PcdGet16 (PcdVirtioScsiMaxTargetLimit
)) {
780 Dev
->MaxTarget
= PcdGet16 (PcdVirtioScsiMaxTargetLimit
);
783 Status
= VIRTIO_CFG_READ (Dev
, MaxLun
, &Dev
->MaxLun
);
784 if (EFI_ERROR (Status
)) {
787 if (Dev
->MaxLun
> PcdGet32 (PcdVirtioScsiMaxLunLimit
)) {
788 Dev
->MaxLun
= PcdGet32 (PcdVirtioScsiMaxLunLimit
);
791 Status
= VIRTIO_CFG_READ (Dev
, MaxSectors
, &Dev
->MaxSectors
);
792 if (EFI_ERROR (Status
)) {
795 if (Dev
->MaxSectors
< 2) {
797 // We must be able to halve it for bidirectional transfers
798 // (see EFI_BAD_BUFFER_SIZE in PopulateRequest()).
800 Status
= EFI_UNSUPPORTED
;
804 Features
&= VIRTIO_SCSI_F_INOUT
| VIRTIO_F_VERSION_1
;
807 // In virtio-1.0, feature negotiation is expected to complete before queue
808 // discovery, and the device can also reject the selected set of features.
810 if (Dev
->VirtIo
->Revision
>= VIRTIO_SPEC_REVISION (1, 0, 0)) {
811 Status
= Virtio10WriteFeatures (Dev
->VirtIo
, Features
, &NextDevStat
);
812 if (EFI_ERROR (Status
)) {
818 // step 4b -- allocate request virtqueue
820 Status
= Dev
->VirtIo
->SetQueueSel (Dev
->VirtIo
, VIRTIO_SCSI_REQUEST_QUEUE
);
821 if (EFI_ERROR (Status
)) {
824 Status
= Dev
->VirtIo
->GetQueueNumMax (Dev
->VirtIo
, &QueueSize
);
825 if (EFI_ERROR (Status
)) {
829 // VirtioScsiPassThru() uses at most four descriptors
832 Status
= EFI_UNSUPPORTED
;
836 Status
= VirtioRingInit (Dev
->VirtIo
, QueueSize
, &Dev
->Ring
);
837 if (EFI_ERROR (Status
)) {
842 // If anything fails from here on, we must release the ring resources
844 Status
= VirtioRingMap (
850 if (EFI_ERROR (Status
)) {
855 // Additional steps for MMIO: align the queue appropriately, and set the
856 // size. If anything fails from here on, we must unmap the ring resources.
858 Status
= Dev
->VirtIo
->SetQueueNum (Dev
->VirtIo
, QueueSize
);
859 if (EFI_ERROR (Status
)) {
863 Status
= Dev
->VirtIo
->SetQueueAlign (Dev
->VirtIo
, EFI_PAGE_SIZE
);
864 if (EFI_ERROR (Status
)) {
869 // step 4c -- Report GPFN (guest-physical frame number) of queue.
871 Status
= Dev
->VirtIo
->SetQueueAddress (
876 if (EFI_ERROR (Status
)) {
881 // step 5 -- Report understood features and guest-tuneables.
883 if (Dev
->VirtIo
->Revision
< VIRTIO_SPEC_REVISION (1, 0, 0)) {
884 Features
&= ~(UINT64
)VIRTIO_F_VERSION_1
;
885 Status
= Dev
->VirtIo
->SetGuestFeatures (Dev
->VirtIo
, Features
);
886 if (EFI_ERROR (Status
)) {
892 // We expect these maximum sizes from the host. Since they are
893 // guest-negotiable, ask for them rather than just checking them.
895 Status
= VIRTIO_CFG_WRITE (Dev
, CdbSize
, VIRTIO_SCSI_CDB_SIZE
);
896 if (EFI_ERROR (Status
)) {
899 Status
= VIRTIO_CFG_WRITE (Dev
, SenseSize
, VIRTIO_SCSI_SENSE_SIZE
);
900 if (EFI_ERROR (Status
)) {
905 // step 6 -- initialization complete
907 NextDevStat
|= VSTAT_DRIVER_OK
;
908 Status
= Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, NextDevStat
);
909 if (EFI_ERROR (Status
)) {
914 // populate the exported interface's attributes
916 Dev
->PassThru
.Mode
= &Dev
->PassThruMode
;
917 Dev
->PassThru
.PassThru
= &VirtioScsiPassThru
;
918 Dev
->PassThru
.GetNextTargetLun
= &VirtioScsiGetNextTargetLun
;
919 Dev
->PassThru
.BuildDevicePath
= &VirtioScsiBuildDevicePath
;
920 Dev
->PassThru
.GetTargetLun
= &VirtioScsiGetTargetLun
;
921 Dev
->PassThru
.ResetChannel
= &VirtioScsiResetChannel
;
922 Dev
->PassThru
.ResetTargetLun
= &VirtioScsiResetTargetLun
;
923 Dev
->PassThru
.GetNextTarget
= &VirtioScsiGetNextTarget
;
926 // AdapterId is a target for which no handle will be created during bus scan.
927 // Prevent any conflict with real devices.
929 Dev
->PassThruMode
.AdapterId
= 0xFFFFFFFF;
932 // Set both physical and logical attributes for non-RAID SCSI channel. See
933 // Driver Writer's Guide for UEFI 2.3.1 v1.01, 20.1.5 Implementing Extended
934 // SCSI Pass Thru Protocol.
936 Dev
->PassThruMode
.Attributes
= EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL
|
937 EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL
;
940 // no restriction on transfer buffer alignment
942 Dev
->PassThruMode
.IoAlign
= 0;
947 Dev
->VirtIo
->UnmapSharedBuffer (Dev
->VirtIo
, Dev
->RingMap
);
950 VirtioRingUninit (Dev
->VirtIo
, &Dev
->Ring
);
954 // Notify the host about our failure to setup: virtio-0.9.5, 2.2.2.1 Device
955 // Status. VirtIo access failure here should not mask the original error.
957 NextDevStat
|= VSTAT_FAILED
;
958 Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, NextDevStat
);
960 Dev
->InOutSupported
= FALSE
;
965 return Status
; // reached only via Failed above
973 IN OUT VSCSI_DEV
*Dev
977 // Reset the virtual device -- see virtio-0.9.5, 2.2.2.1 Device Status. When
978 // VIRTIO_CFG_WRITE() returns, the host will have learned to stay away from
979 // the old comms area.
981 Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, 0);
983 Dev
->InOutSupported
= FALSE
;
988 Dev
->VirtIo
->UnmapSharedBuffer (Dev
->VirtIo
, Dev
->RingMap
);
989 VirtioRingUninit (Dev
->VirtIo
, &Dev
->Ring
);
991 SetMem (&Dev
->PassThru
, sizeof Dev
->PassThru
, 0x00);
992 SetMem (&Dev
->PassThruMode
, sizeof Dev
->PassThruMode
, 0x00);
997 // Event notification function enqueued by ExitBootServices().
1003 VirtioScsiExitBoot (
1011 // Reset the device. This causes the hypervisor to forget about the virtio
1014 // We allocated said ring in EfiBootServicesData type memory, and code
1015 // executing after ExitBootServices() is permitted to overwrite it.
1018 Dev
->VirtIo
->SetDeviceStatus (Dev
->VirtIo
, 0);
1021 // Unmap the ring buffer so that hypervisor will not be able to get
1022 // readable data after device reset.
1024 Dev
->VirtIo
->UnmapSharedBuffer (Dev
->VirtIo
, Dev
->RingMap
);
1029 // Probe, start and stop functions of this driver, called by the DXE core for
1030 // specific devices.
1032 // The following specifications document these interfaces:
1033 // - Driver Writer's Guide for UEFI 2.3.1 v1.01, 9 Driver Binding Protocol
1034 // - UEFI Spec 2.3.1 + Errata C, 10.1 EFI Driver Binding Protocol
1036 // The implementation follows:
1037 // - Driver Writer's Guide for UEFI 2.3.1 v1.01
1038 // - 5.1.3.4 OpenProtocol() and CloseProtocol()
1039 // - UEFI Spec 2.3.1 + Errata C
1040 // - 6.3 Protocol Handler Services
1045 VirtioScsiDriverBindingSupported (
1046 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
1047 IN EFI_HANDLE DeviceHandle
,
1048 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
1052 VIRTIO_DEVICE_PROTOCOL
*VirtIo
;
1055 // Attempt to open the device with the VirtIo set of interfaces. On success,
1056 // the protocol is "instantiated" for the VirtIo device. Covers duplicate open
1057 // attempts (EFI_ALREADY_STARTED).
1059 Status
= gBS
->OpenProtocol (
1060 DeviceHandle
, // candidate device
1061 &gVirtioDeviceProtocolGuid
, // for generic VirtIo access
1062 (VOID
**)&VirtIo
, // handle to instantiate
1063 This
->DriverBindingHandle
, // requestor driver identity
1064 DeviceHandle
, // ControllerHandle, according to
1065 // the UEFI Driver Model
1066 EFI_OPEN_PROTOCOL_BY_DRIVER
// get exclusive VirtIo access to
1067 // the device; to be released
1069 if (EFI_ERROR (Status
)) {
1073 if (VirtIo
->SubSystemDeviceId
!= VIRTIO_SUBSYSTEM_SCSI_HOST
) {
1074 Status
= EFI_UNSUPPORTED
;
1078 // We needed VirtIo access only transitorily, to see whether we support the
1081 gBS
->CloseProtocol (DeviceHandle
, &gVirtioDeviceProtocolGuid
,
1082 This
->DriverBindingHandle
, DeviceHandle
);
1089 VirtioScsiDriverBindingStart (
1090 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
1091 IN EFI_HANDLE DeviceHandle
,
1092 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
1098 Dev
= (VSCSI_DEV
*) AllocateZeroPool (sizeof *Dev
);
1100 return EFI_OUT_OF_RESOURCES
;
1103 Status
= gBS
->OpenProtocol (DeviceHandle
, &gVirtioDeviceProtocolGuid
,
1104 (VOID
**)&Dev
->VirtIo
, This
->DriverBindingHandle
,
1105 DeviceHandle
, EFI_OPEN_PROTOCOL_BY_DRIVER
);
1106 if (EFI_ERROR (Status
)) {
1107 goto FreeVirtioScsi
;
1111 // VirtIo access granted, configure virtio-scsi device.
1113 Status
= VirtioScsiInit (Dev
);
1114 if (EFI_ERROR (Status
)) {
1118 Status
= gBS
->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES
, TPL_CALLBACK
,
1119 &VirtioScsiExitBoot
, Dev
, &Dev
->ExitBoot
);
1120 if (EFI_ERROR (Status
)) {
1125 // Setup complete, attempt to export the driver instance's PassThru
1128 Dev
->Signature
= VSCSI_SIG
;
1129 Status
= gBS
->InstallProtocolInterface (&DeviceHandle
,
1130 &gEfiExtScsiPassThruProtocolGuid
, EFI_NATIVE_INTERFACE
,
1132 if (EFI_ERROR (Status
)) {
1139 gBS
->CloseEvent (Dev
->ExitBoot
);
1142 VirtioScsiUninit (Dev
);
1145 gBS
->CloseProtocol (DeviceHandle
, &gVirtioDeviceProtocolGuid
,
1146 This
->DriverBindingHandle
, DeviceHandle
);
1157 VirtioScsiDriverBindingStop (
1158 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
1159 IN EFI_HANDLE DeviceHandle
,
1160 IN UINTN NumberOfChildren
,
1161 IN EFI_HANDLE
*ChildHandleBuffer
1165 EFI_EXT_SCSI_PASS_THRU_PROTOCOL
*PassThru
;
1168 Status
= gBS
->OpenProtocol (
1169 DeviceHandle
, // candidate device
1170 &gEfiExtScsiPassThruProtocolGuid
, // retrieve the SCSI iface
1171 (VOID
**)&PassThru
, // target pointer
1172 This
->DriverBindingHandle
, // requestor driver ident.
1173 DeviceHandle
, // lookup req. for dev.
1174 EFI_OPEN_PROTOCOL_GET_PROTOCOL
// lookup only, no new ref.
1176 if (EFI_ERROR (Status
)) {
1180 Dev
= VIRTIO_SCSI_FROM_PASS_THRU (PassThru
);
1183 // Handle Stop() requests for in-use driver instances gracefully.
1185 Status
= gBS
->UninstallProtocolInterface (DeviceHandle
,
1186 &gEfiExtScsiPassThruProtocolGuid
, &Dev
->PassThru
);
1187 if (EFI_ERROR (Status
)) {
1191 gBS
->CloseEvent (Dev
->ExitBoot
);
1193 VirtioScsiUninit (Dev
);
1195 gBS
->CloseProtocol (DeviceHandle
, &gVirtioDeviceProtocolGuid
,
1196 This
->DriverBindingHandle
, DeviceHandle
);
1205 // The static object that groups the Supported() (ie. probe), Start() and
1206 // Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
1207 // C, 10.1 EFI Driver Binding Protocol.
1209 STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding
= {
1210 &VirtioScsiDriverBindingSupported
,
1211 &VirtioScsiDriverBindingStart
,
1212 &VirtioScsiDriverBindingStop
,
1213 0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
1214 NULL
, // ImageHandle, to be overwritten by
1215 // EfiLibInstallDriverBindingComponentName2() in VirtioScsiEntryPoint()
1216 NULL
// DriverBindingHandle, ditto
1221 // The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
1222 // EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
1223 // in English, for display on standard console devices. This is recommended for
1224 // UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
1225 // Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
1227 // Device type names ("Virtio SCSI Host Device") are not formatted because the
1228 // driver supports only that device type. Therefore the driver name suffices
1229 // for unambiguous identification.
1233 EFI_UNICODE_STRING_TABLE mDriverNameTable
[] = {
1234 { "eng;en", L
"Virtio SCSI Host Driver" },
1239 EFI_COMPONENT_NAME_PROTOCOL gComponentName
;
1243 VirtioScsiGetDriverName (
1244 IN EFI_COMPONENT_NAME_PROTOCOL
*This
,
1246 OUT CHAR16
**DriverName
1249 return LookupUnicodeString2 (
1251 This
->SupportedLanguages
,
1254 (BOOLEAN
)(This
== &gComponentName
) // Iso639Language
1260 VirtioScsiGetDeviceName (
1261 IN EFI_COMPONENT_NAME_PROTOCOL
*This
,
1262 IN EFI_HANDLE DeviceHandle
,
1263 IN EFI_HANDLE ChildHandle
,
1265 OUT CHAR16
**ControllerName
1268 return EFI_UNSUPPORTED
;
1272 EFI_COMPONENT_NAME_PROTOCOL gComponentName
= {
1273 &VirtioScsiGetDriverName
,
1274 &VirtioScsiGetDeviceName
,
1275 "eng" // SupportedLanguages, ISO 639-2 language codes
1279 EFI_COMPONENT_NAME2_PROTOCOL gComponentName2
= {
1280 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME
) &VirtioScsiGetDriverName
,
1281 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME
) &VirtioScsiGetDeviceName
,
1282 "en" // SupportedLanguages, RFC 4646 language codes
1287 // Entry point of this driver.
1291 VirtioScsiEntryPoint (
1292 IN EFI_HANDLE ImageHandle
,
1293 IN EFI_SYSTEM_TABLE
*SystemTable
1296 return EfiLibInstallDriverBindingComponentName2 (