2 NvmExpressDxe driver is used to manage non-volatile memory subsystem which follows
3 NVM Express specification.
5 (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
6 Copyright (c) 2013 - 2016, Intel Corporation. All rights reserved.<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php.
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "NvmExpress.h"
20 Dump the execution status from a given completion queue entry.
22 @param[in] Cq A pointer to the NVME_CQ item.
30 DEBUG ((EFI_D_VERBOSE
, "Dump NVMe Completion Entry Status from [0x%x]:\n", Cq
));
32 DEBUG ((EFI_D_VERBOSE
, " SQ Identifier : [0x%x], Phase Tag : [%d], Cmd Identifier : [0x%x]\n", Cq
->Sqid
, Cq
->Pt
, Cq
->Cid
));
34 DEBUG ((EFI_D_VERBOSE
, " NVMe Cmd Execution Result - "));
40 DEBUG ((EFI_D_VERBOSE
, "Successful Completion\n"));
43 DEBUG ((EFI_D_VERBOSE
, "Invalid Command Opcode\n"));
46 DEBUG ((EFI_D_VERBOSE
, "Invalid Field in Command\n"));
49 DEBUG ((EFI_D_VERBOSE
, "Command ID Conflict\n"));
52 DEBUG ((EFI_D_VERBOSE
, "Data Transfer Error\n"));
55 DEBUG ((EFI_D_VERBOSE
, "Commands Aborted due to Power Loss Notification\n"));
58 DEBUG ((EFI_D_VERBOSE
, "Internal Device Error\n"));
61 DEBUG ((EFI_D_VERBOSE
, "Command Abort Requested\n"));
64 DEBUG ((EFI_D_VERBOSE
, "Command Aborted due to SQ Deletion\n"));
67 DEBUG ((EFI_D_VERBOSE
, "Command Aborted due to Failed Fused Command\n"));
70 DEBUG ((EFI_D_VERBOSE
, "Command Aborted due to Missing Fused Command\n"));
73 DEBUG ((EFI_D_VERBOSE
, "Invalid Namespace or Format\n"));
76 DEBUG ((EFI_D_VERBOSE
, "Command Sequence Error\n"));
79 DEBUG ((EFI_D_VERBOSE
, "Invalid SGL Last Segment Descriptor\n"));
82 DEBUG ((EFI_D_VERBOSE
, "Invalid Number of SGL Descriptors\n"));
85 DEBUG ((EFI_D_VERBOSE
, "Data SGL Length Invalid\n"));
88 DEBUG ((EFI_D_VERBOSE
, "Metadata SGL Length Invalid\n"));
91 DEBUG ((EFI_D_VERBOSE
, "SGL Descriptor Type Invalid\n"));
94 DEBUG ((EFI_D_VERBOSE
, "LBA Out of Range\n"));
97 DEBUG ((EFI_D_VERBOSE
, "Capacity Exceeded\n"));
100 DEBUG ((EFI_D_VERBOSE
, "Namespace Not Ready\n"));
103 DEBUG ((EFI_D_VERBOSE
, "Reservation Conflict\n"));
111 DEBUG ((EFI_D_VERBOSE
, "Completion Queue Invalid\n"));
114 DEBUG ((EFI_D_VERBOSE
, "Invalid Queue Identifier\n"));
117 DEBUG ((EFI_D_VERBOSE
, "Maximum Queue Size Exceeded\n"));
120 DEBUG ((EFI_D_VERBOSE
, "Abort Command Limit Exceeded\n"));
123 DEBUG ((EFI_D_VERBOSE
, "Asynchronous Event Request Limit Exceeded\n"));
126 DEBUG ((EFI_D_VERBOSE
, "Invalid Firmware Slot\n"));
129 DEBUG ((EFI_D_VERBOSE
, "Invalid Firmware Image\n"));
132 DEBUG ((EFI_D_VERBOSE
, "Invalid Interrupt Vector\n"));
135 DEBUG ((EFI_D_VERBOSE
, "Invalid Log Page\n"));
138 DEBUG ((EFI_D_VERBOSE
, "Invalid Format\n"));
141 DEBUG ((EFI_D_VERBOSE
, "Firmware Application Requires Conventional Reset\n"));
144 DEBUG ((EFI_D_VERBOSE
, "Invalid Queue Deletion\n"));
147 DEBUG ((EFI_D_VERBOSE
, "Feature Identifier Not Saveable\n"));
150 DEBUG ((EFI_D_VERBOSE
, "Feature Not Changeable\n"));
153 DEBUG ((EFI_D_VERBOSE
, "Feature Not Namespace Specific\n"));
156 DEBUG ((EFI_D_VERBOSE
, "Firmware Application Requires NVM Subsystem Reset\n"));
159 DEBUG ((EFI_D_VERBOSE
, "Conflicting Attributes\n"));
162 DEBUG ((EFI_D_VERBOSE
, "Invalid Protection Information\n"));
165 DEBUG ((EFI_D_VERBOSE
, "Attempted Write to Read Only Range\n"));
173 DEBUG ((EFI_D_VERBOSE
, "Write Fault\n"));
176 DEBUG ((EFI_D_VERBOSE
, "Unrecovered Read Error\n"));
179 DEBUG ((EFI_D_VERBOSE
, "End-to-end Guard Check Error\n"));
182 DEBUG ((EFI_D_VERBOSE
, "End-to-end Application Tag Check Error\n"));
185 DEBUG ((EFI_D_VERBOSE
, "End-to-end Reference Tag Check Error\n"));
188 DEBUG ((EFI_D_VERBOSE
, "Compare Failure\n"));
191 DEBUG ((EFI_D_VERBOSE
, "Access Denied\n"));
202 Create PRP lists for data transfer which is larger than 2 memory pages.
203 Note here we calcuate the number of required PRP lists and allocate them at one time.
205 @param[in] PciIo A pointer to the EFI_PCI_IO_PROTOCOL instance.
206 @param[in] PhysicalAddr The physical base address of data buffer.
207 @param[in] Pages The number of pages to be transfered.
208 @param[out] PrpListHost The host base address of PRP lists.
209 @param[in,out] PrpListNo The number of PRP List.
210 @param[out] Mapping The mapping value returned from PciIo.Map().
212 @retval The pointer to the first PRP List of the PRP lists.
217 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
218 IN EFI_PHYSICAL_ADDRESS PhysicalAddr
,
220 OUT VOID
**PrpListHost
,
221 IN OUT UINTN
*PrpListNo
,
230 EFI_PHYSICAL_ADDRESS PrpListPhyAddr
;
235 // The number of Prp Entry in a memory page.
237 PrpEntryNo
= EFI_PAGE_SIZE
/ sizeof (UINT64
);
240 // Calculate total PrpList number.
242 *PrpListNo
= (UINTN
)DivU64x64Remainder ((UINT64
)Pages
, (UINT64
)PrpEntryNo
- 1, &Remainder
);
243 if (*PrpListNo
== 0) {
245 } else if ((Remainder
!= 0) && (Remainder
!= 1)) {
247 } else if (Remainder
== 1) {
248 Remainder
= PrpEntryNo
;
249 } else if (Remainder
== 0) {
250 Remainder
= PrpEntryNo
- 1;
253 Status
= PciIo
->AllocateBuffer (
262 if (EFI_ERROR (Status
)) {
266 Bytes
= EFI_PAGES_TO_SIZE (*PrpListNo
);
267 Status
= PciIo
->Map (
269 EfiPciIoOperationBusMasterCommonBuffer
,
276 if (EFI_ERROR (Status
) || (Bytes
!= EFI_PAGES_TO_SIZE (*PrpListNo
))) {
277 DEBUG ((EFI_D_ERROR
, "NvmeCreatePrpList: create PrpList failure!\n"));
281 // Fill all PRP lists except of last one.
283 ZeroMem (*PrpListHost
, Bytes
);
284 for (PrpListIndex
= 0; PrpListIndex
< *PrpListNo
- 1; ++PrpListIndex
) {
285 PrpListBase
= *(UINT64
*)PrpListHost
+ PrpListIndex
* EFI_PAGE_SIZE
;
287 for (PrpEntryIndex
= 0; PrpEntryIndex
< PrpEntryNo
; ++PrpEntryIndex
) {
288 if (PrpEntryIndex
!= PrpEntryNo
- 1) {
290 // Fill all PRP entries except of last one.
292 *((UINT64
*)(UINTN
)PrpListBase
+ PrpEntryIndex
) = PhysicalAddr
;
293 PhysicalAddr
+= EFI_PAGE_SIZE
;
296 // Fill last PRP entries with next PRP List pointer.
298 *((UINT64
*)(UINTN
)PrpListBase
+ PrpEntryIndex
) = PrpListPhyAddr
+ (PrpListIndex
+ 1) * EFI_PAGE_SIZE
;
303 // Fill last PRP list.
305 PrpListBase
= *(UINT64
*)PrpListHost
+ PrpListIndex
* EFI_PAGE_SIZE
;
306 for (PrpEntryIndex
= 0; PrpEntryIndex
< Remainder
; ++PrpEntryIndex
) {
307 *((UINT64
*)(UINTN
)PrpListBase
+ PrpEntryIndex
) = PhysicalAddr
;
308 PhysicalAddr
+= EFI_PAGE_SIZE
;
311 return (VOID
*)(UINTN
)PrpListPhyAddr
;
314 PciIo
->FreeBuffer (PciIo
, *PrpListNo
, *PrpListHost
);
320 Sends an NVM Express Command Packet to an NVM Express controller or namespace. This function supports
321 both blocking I/O and non-blocking I/O. The blocking I/O functionality is required, and the non-blocking
322 I/O functionality is optional.
325 @param[in] This A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
326 @param[in] NamespaceId A 32 bit namespace ID as defined in the NVMe specification to which the NVM Express Command
327 Packet will be sent. A value of 0 denotes the NVM Express controller, a value of all 0xFF's
328 (all bytes are 0xFF) in the namespace ID specifies that the command packet should be sent to
329 all valid namespaces.
330 @param[in,out] Packet A pointer to the NVM Express Command Packet.
331 @param[in] Event If non-blocking I/O is not supported then Event is ignored, and blocking I/O is performed.
332 If Event is NULL, then blocking I/O is performed. If Event is not NULL and non-blocking I/O
333 is supported, then non-blocking I/O is performed, and Event will be signaled when the NVM
334 Express Command Packet completes.
336 @retval EFI_SUCCESS The NVM Express Command Packet was sent by the host. TransferLength bytes were transferred
337 to, or from DataBuffer.
338 @retval EFI_BAD_BUFFER_SIZE The NVM Express Command Packet was not executed. The number of bytes that could be transferred
339 is returned in TransferLength.
340 @retval EFI_NOT_READY The NVM Express Command Packet could not be sent because the controller is not ready. The caller
341 may retry again later.
342 @retval EFI_DEVICE_ERROR A device error occurred while attempting to send the NVM Express Command Packet.
343 @retval EFI_INVALID_PARAMETER NamespaceId or the contents of EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET are invalid. The NVM
344 Express Command Packet was not sent, so no additional status information is available.
345 @retval EFI_UNSUPPORTED The command described by the NVM Express Command Packet is not supported by the NVM Express
346 controller. The NVM Express Command Packet was not sent so no additional status information
348 @retval EFI_TIMEOUT A timeout occurred while waiting for the NVM Express Command Packet to execute.
354 IN EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*This
,
355 IN UINT32 NamespaceId
,
356 IN OUT EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET
*Packet
,
357 IN EFI_EVENT Event OPTIONAL
360 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
362 EFI_PCI_IO_PROTOCOL
*PciIo
;
368 EFI_EVENT TimerEvent
;
369 EFI_PCI_IO_PROTOCOL_OPERATION Flag
;
370 EFI_PHYSICAL_ADDRESS PhyAddr
;
382 NVME_PASS_THRU_ASYNC_REQ
*AsyncRequest
;
386 // check the data fields in Packet parameter.
388 if ((This
== NULL
) || (Packet
== NULL
)) {
389 return EFI_INVALID_PARAMETER
;
392 if ((Packet
->NvmeCmd
== NULL
) || (Packet
->NvmeCompletion
== NULL
)) {
393 return EFI_INVALID_PARAMETER
;
396 if (Packet
->QueueType
!= NVME_ADMIN_QUEUE
&& Packet
->QueueType
!= NVME_IO_QUEUE
) {
397 return EFI_INVALID_PARAMETER
;
401 // 'Attributes' with neither EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_LOGICAL nor
402 // EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_PHYSICAL set is an illegal
405 Attributes
= This
->Mode
->Attributes
;
406 if ((Attributes
& (EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_PHYSICAL
|
407 EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_LOGICAL
)) == 0) {
408 return EFI_INVALID_PARAMETER
;
412 // Buffer alignment check for TransferBuffer & MetadataBuffer.
414 IoAlign
= This
->Mode
->IoAlign
;
415 if (IoAlign
> 0 && (((UINTN
) Packet
->TransferBuffer
& (IoAlign
- 1)) != 0)) {
416 return EFI_INVALID_PARAMETER
;
419 if (IoAlign
> 0 && (((UINTN
) Packet
->MetadataBuffer
& (IoAlign
- 1)) != 0)) {
420 return EFI_INVALID_PARAMETER
;
423 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (This
);
426 // Check NamespaceId is valid or not.
428 if ((NamespaceId
> Private
->ControllerData
->Nn
) &&
429 (NamespaceId
!= (UINT32
) -1)) {
430 return EFI_INVALID_PARAMETER
;
434 // Check whether TransferLength exceeds the maximum data transfer size.
436 if (Private
->ControllerData
->Mdts
!= 0) {
437 MaxTransLen
= (1 << (Private
->ControllerData
->Mdts
)) *
438 (1 << (Private
->Cap
.Mpsmin
+ 12));
439 if (Packet
->TransferLength
> MaxTransLen
) {
440 Packet
->TransferLength
= MaxTransLen
;
441 return EFI_BAD_BUFFER_SIZE
;
445 PciIo
= Private
->PciIo
;
453 Status
= EFI_SUCCESS
;
455 if (Packet
->QueueType
== NVME_ADMIN_QUEUE
) {
464 // Submission queue full check.
466 if ((Private
->SqTdbl
[QueueId
].Sqt
+ 1) % (NVME_ASYNC_CSQ_SIZE
+ 1) ==
467 Private
->AsyncSqHead
) {
468 return EFI_NOT_READY
;
472 Sq
= Private
->SqBuffer
[QueueId
] + Private
->SqTdbl
[QueueId
].Sqt
;
473 Cq
= Private
->CqBuffer
[QueueId
] + Private
->CqHdbl
[QueueId
].Cqh
;
475 if (Packet
->NvmeCmd
->Nsid
!= NamespaceId
) {
476 return EFI_INVALID_PARAMETER
;
479 ZeroMem (Sq
, sizeof (NVME_SQ
));
480 Sq
->Opc
= (UINT8
)Packet
->NvmeCmd
->Cdw0
.Opcode
;
481 Sq
->Fuse
= (UINT8
)Packet
->NvmeCmd
->Cdw0
.FusedOperation
;
482 Sq
->Cid
= Private
->Cid
[QueueId
]++;
483 Sq
->Nsid
= Packet
->NvmeCmd
->Nsid
;
486 // Currently we only support PRP for data transfer, SGL is NOT supported.
488 ASSERT (Sq
->Psdt
== 0);
490 DEBUG ((EFI_D_ERROR
, "NvmExpressPassThru: doesn't support SGL mechanism\n"));
491 return EFI_UNSUPPORTED
;
494 Sq
->Prp
[0] = (UINT64
)(UINTN
)Packet
->TransferBuffer
;
496 // If the NVMe cmd has data in or out, then mapping the user buffer to the PCI controller specific addresses.
497 // Note here we don't handle data buffer for CreateIOSubmitionQueue and CreateIOCompletionQueue cmds because
498 // these two cmds are special which requires their data buffer must support simultaneous access by both the
499 // processor and a PCI Bus Master. It's caller's responsbility to ensure this.
501 if (((Sq
->Opc
& (BIT0
| BIT1
)) != 0) && (Sq
->Opc
!= NVME_ADMIN_CRIOCQ_CMD
) && (Sq
->Opc
!= NVME_ADMIN_CRIOSQ_CMD
)) {
502 if ((Packet
->TransferLength
== 0) || (Packet
->TransferBuffer
== NULL
)) {
503 return EFI_INVALID_PARAMETER
;
506 if ((Sq
->Opc
& BIT0
) != 0) {
507 Flag
= EfiPciIoOperationBusMasterRead
;
509 Flag
= EfiPciIoOperationBusMasterWrite
;
512 MapLength
= Packet
->TransferLength
;
513 Status
= PciIo
->Map (
516 Packet
->TransferBuffer
,
521 if (EFI_ERROR (Status
) || (Packet
->TransferLength
!= MapLength
)) {
522 return EFI_OUT_OF_RESOURCES
;
525 Sq
->Prp
[0] = PhyAddr
;
528 if((Packet
->MetadataLength
!= 0) && (Packet
->MetadataBuffer
!= NULL
)) {
529 MapLength
= Packet
->MetadataLength
;
530 Status
= PciIo
->Map (
533 Packet
->MetadataBuffer
,
538 if (EFI_ERROR (Status
) || (Packet
->MetadataLength
!= MapLength
)) {
544 return EFI_OUT_OF_RESOURCES
;
550 // If the buffer size spans more than two memory pages (page size as defined in CC.Mps),
551 // then build a PRP list in the second PRP submission queue entry.
553 Offset
= ((UINT16
)Sq
->Prp
[0]) & (EFI_PAGE_SIZE
- 1);
554 Bytes
= Packet
->TransferLength
;
556 if ((Offset
+ Bytes
) > (EFI_PAGE_SIZE
* 2)) {
558 // Create PrpList for remaining data buffer.
560 PhyAddr
= (Sq
->Prp
[0] + EFI_PAGE_SIZE
) & ~(EFI_PAGE_SIZE
- 1);
561 Prp
= NvmeCreatePrpList (PciIo
, PhyAddr
, EFI_SIZE_TO_PAGES(Offset
+ Bytes
) - 1, &PrpListHost
, &PrpListNo
, &MapPrpList
);
566 Sq
->Prp
[1] = (UINT64
)(UINTN
)Prp
;
567 } else if ((Offset
+ Bytes
) > EFI_PAGE_SIZE
) {
568 Sq
->Prp
[1] = (Sq
->Prp
[0] + EFI_PAGE_SIZE
) & ~(EFI_PAGE_SIZE
- 1);
571 if(Packet
->NvmeCmd
->Flags
& CDW2_VALID
) {
572 Sq
->Rsvd2
= (UINT64
)Packet
->NvmeCmd
->Cdw2
;
574 if(Packet
->NvmeCmd
->Flags
& CDW3_VALID
) {
575 Sq
->Rsvd2
|= LShiftU64 ((UINT64
)Packet
->NvmeCmd
->Cdw3
, 32);
577 if(Packet
->NvmeCmd
->Flags
& CDW10_VALID
) {
578 Sq
->Payload
.Raw
.Cdw10
= Packet
->NvmeCmd
->Cdw10
;
580 if(Packet
->NvmeCmd
->Flags
& CDW11_VALID
) {
581 Sq
->Payload
.Raw
.Cdw11
= Packet
->NvmeCmd
->Cdw11
;
583 if(Packet
->NvmeCmd
->Flags
& CDW12_VALID
) {
584 Sq
->Payload
.Raw
.Cdw12
= Packet
->NvmeCmd
->Cdw12
;
586 if(Packet
->NvmeCmd
->Flags
& CDW13_VALID
) {
587 Sq
->Payload
.Raw
.Cdw13
= Packet
->NvmeCmd
->Cdw13
;
589 if(Packet
->NvmeCmd
->Flags
& CDW14_VALID
) {
590 Sq
->Payload
.Raw
.Cdw14
= Packet
->NvmeCmd
->Cdw14
;
592 if(Packet
->NvmeCmd
->Flags
& CDW15_VALID
) {
593 Sq
->Payload
.Raw
.Cdw15
= Packet
->NvmeCmd
->Cdw15
;
597 // Ring the submission queue doorbell.
600 Private
->SqTdbl
[QueueId
].Sqt
=
601 (Private
->SqTdbl
[QueueId
].Sqt
+ 1) % (NVME_ASYNC_CSQ_SIZE
+ 1);
603 Private
->SqTdbl
[QueueId
].Sqt
^= 1;
605 Data
= ReadUnaligned32 ((UINT32
*)&Private
->SqTdbl
[QueueId
]);
610 NVME_SQTDBL_OFFSET(QueueId
, Private
->Cap
.Dstrd
),
616 // For non-blocking requests, return directly if the command is placed
617 // in the submission queue.
620 AsyncRequest
= AllocateZeroPool (sizeof (NVME_PASS_THRU_ASYNC_REQ
));
621 if (AsyncRequest
== NULL
) {
622 Status
= EFI_DEVICE_ERROR
;
626 AsyncRequest
->Signature
= NVME_PASS_THRU_ASYNC_REQ_SIG
;
627 AsyncRequest
->Packet
= Packet
;
628 AsyncRequest
->CommandId
= Sq
->Cid
;
629 AsyncRequest
->CallerEvent
= Event
;
631 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
632 InsertTailList (&Private
->AsyncPassThruQueue
, &AsyncRequest
->Link
);
633 gBS
->RestoreTPL (OldTpl
);
638 Status
= gBS
->CreateEvent (
645 if (EFI_ERROR (Status
)) {
649 Status
= gBS
->SetTimer(TimerEvent
, TimerRelative
, Packet
->CommandTimeout
);
651 if (EFI_ERROR(Status
)) {
656 // Wait for completion queue to get filled in.
658 Status
= EFI_TIMEOUT
;
659 while (EFI_ERROR (gBS
->CheckEvent (TimerEvent
))) {
660 if (Cq
->Pt
!= Private
->Pt
[QueueId
]) {
661 Status
= EFI_SUCCESS
;
667 // Check the NVMe cmd execution result
669 if (Status
!= EFI_TIMEOUT
) {
670 if ((Cq
->Sct
== 0) && (Cq
->Sc
== 0)) {
671 Status
= EFI_SUCCESS
;
673 Status
= EFI_DEVICE_ERROR
;
675 // Copy the Respose Queue entry for this command to the callers response buffer
677 CopyMem(Packet
->NvmeCompletion
, Cq
, sizeof(EFI_NVM_EXPRESS_COMPLETION
));
680 // Dump every completion entry status for debugging.
688 if ((Private
->CqHdbl
[QueueId
].Cqh
^= 1) == 0) {
689 Private
->Pt
[QueueId
] ^= 1;
692 Data
= ReadUnaligned32 ((UINT32
*)&Private
->CqHdbl
[QueueId
]);
697 NVME_CQHDBL_OFFSET(QueueId
, Private
->Cap
.Dstrd
),
703 if (MapData
!= NULL
) {
710 if (MapMeta
!= NULL
) {
717 if (MapPrpList
!= NULL
) {
725 PciIo
->FreeBuffer (PciIo
, PrpListNo
, PrpListHost
);
728 if (TimerEvent
!= NULL
) {
729 gBS
->CloseEvent (TimerEvent
);
735 Used to retrieve the next namespace ID for this NVM Express controller.
737 The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.GetNextNamespace() function retrieves the next valid
738 namespace ID on this NVM Express controller.
740 If on input the value pointed to by NamespaceId is 0xFFFFFFFF, then the first valid namespace
741 ID defined on the NVM Express controller is returned in the location pointed to by NamespaceId
742 and a status of EFI_SUCCESS is returned.
744 If on input the value pointed to by NamespaceId is an invalid namespace ID other than 0xFFFFFFFF,
745 then EFI_INVALID_PARAMETER is returned.
747 If on input the value pointed to by NamespaceId is a valid namespace ID, then the next valid
748 namespace ID on the NVM Express controller is returned in the location pointed to by NamespaceId,
749 and EFI_SUCCESS is returned.
751 If the value pointed to by NamespaceId is the namespace ID of the last namespace on the NVM
752 Express controller, then EFI_NOT_FOUND is returned.
754 @param[in] This A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
755 @param[in,out] NamespaceId On input, a pointer to a legal NamespaceId for an NVM Express
756 namespace present on the NVM Express controller. On output, a
757 pointer to the next NamespaceId of an NVM Express namespace on
758 an NVM Express controller. An input value of 0xFFFFFFFF retrieves
759 the first NamespaceId for an NVM Express namespace present on an
760 NVM Express controller.
762 @retval EFI_SUCCESS The Namespace ID of the next Namespace was returned.
763 @retval EFI_NOT_FOUND There are no more namespaces defined on this controller.
764 @retval EFI_INVALID_PARAMETER NamespaceId is an invalid value other than 0xFFFFFFFF.
769 NvmExpressGetNextNamespace (
770 IN EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*This
,
771 IN OUT UINT32
*NamespaceId
774 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
775 NVME_ADMIN_NAMESPACE_DATA
*NamespaceData
;
776 UINT32 NextNamespaceId
;
779 if ((This
== NULL
) || (NamespaceId
== NULL
)) {
780 return EFI_INVALID_PARAMETER
;
783 NamespaceData
= NULL
;
784 Status
= EFI_NOT_FOUND
;
786 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (This
);
788 // If the NamespaceId input value is 0xFFFFFFFF, then get the first valid namespace ID
790 if (*NamespaceId
== 0xFFFFFFFF) {
792 // Start with the first namespace ID
796 // Allocate buffer for Identify Namespace data.
798 NamespaceData
= (NVME_ADMIN_NAMESPACE_DATA
*)AllocateZeroPool (sizeof (NVME_ADMIN_NAMESPACE_DATA
));
800 if (NamespaceData
== NULL
) {
801 return EFI_NOT_FOUND
;
804 Status
= NvmeIdentifyNamespace (Private
, NextNamespaceId
, NamespaceData
);
805 if (EFI_ERROR(Status
)) {
809 *NamespaceId
= NextNamespaceId
;
811 if (*NamespaceId
> Private
->ControllerData
->Nn
) {
812 return EFI_INVALID_PARAMETER
;
815 NextNamespaceId
= *NamespaceId
+ 1;
816 if (NextNamespaceId
> Private
->ControllerData
->Nn
) {
817 return EFI_NOT_FOUND
;
821 // Allocate buffer for Identify Namespace data.
823 NamespaceData
= (NVME_ADMIN_NAMESPACE_DATA
*)AllocateZeroPool (sizeof (NVME_ADMIN_NAMESPACE_DATA
));
824 if (NamespaceData
== NULL
) {
825 return EFI_NOT_FOUND
;
828 Status
= NvmeIdentifyNamespace (Private
, NextNamespaceId
, NamespaceData
);
829 if (EFI_ERROR(Status
)) {
833 *NamespaceId
= NextNamespaceId
;
837 if (NamespaceData
!= NULL
) {
838 FreePool(NamespaceData
);
845 Used to translate a device path node to a namespace ID.
847 The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.GetNamespace() function determines the namespace ID associated with the
848 namespace described by DevicePath.
850 If DevicePath is a device path node type that the NVM Express Pass Thru driver supports, then the NVM Express
851 Pass Thru driver will attempt to translate the contents DevicePath into a namespace ID.
853 If this translation is successful, then that namespace ID is returned in NamespaceId, and EFI_SUCCESS is returned
855 @param[in] This A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
856 @param[in] DevicePath A pointer to the device path node that describes an NVM Express namespace on
857 the NVM Express controller.
858 @param[out] NamespaceId The NVM Express namespace ID contained in the device path node.
860 @retval EFI_SUCCESS DevicePath was successfully translated to NamespaceId.
861 @retval EFI_INVALID_PARAMETER If DevicePath or NamespaceId are NULL, then EFI_INVALID_PARAMETER is returned.
862 @retval EFI_UNSUPPORTED If DevicePath is not a device path node type that the NVM Express Pass Thru driver
863 supports, then EFI_UNSUPPORTED is returned.
864 @retval EFI_NOT_FOUND If DevicePath is a device path node type that the NVM Express Pass Thru driver
865 supports, but there is not a valid translation from DevicePath to a namespace ID,
866 then EFI_NOT_FOUND is returned.
870 NvmExpressGetNamespace (
871 IN EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*This
,
872 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
873 OUT UINT32
*NamespaceId
876 NVME_NAMESPACE_DEVICE_PATH
*Node
;
877 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
879 if ((This
== NULL
) || (DevicePath
== NULL
) || (NamespaceId
== NULL
)) {
880 return EFI_INVALID_PARAMETER
;
883 if (DevicePath
->Type
!= MESSAGING_DEVICE_PATH
) {
884 return EFI_UNSUPPORTED
;
887 Node
= (NVME_NAMESPACE_DEVICE_PATH
*)DevicePath
;
888 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (This
);
890 if (DevicePath
->SubType
== MSG_NVME_NAMESPACE_DP
) {
891 if (DevicePathNodeLength(DevicePath
) != sizeof(NVME_NAMESPACE_DEVICE_PATH
)) {
892 return EFI_NOT_FOUND
;
896 // Check NamespaceId in the device path node is valid or not.
898 if ((Node
->NamespaceId
== 0) ||
899 (Node
->NamespaceId
> Private
->ControllerData
->Nn
)) {
900 return EFI_NOT_FOUND
;
903 *NamespaceId
= Node
->NamespaceId
;
907 return EFI_UNSUPPORTED
;
912 Used to allocate and build a device path node for an NVM Express namespace on an NVM Express controller.
914 The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.BuildDevicePath() function allocates and builds a single device
915 path node for the NVM Express namespace specified by NamespaceId.
917 If the NamespaceId is not valid, then EFI_NOT_FOUND is returned.
919 If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned.
921 If there are not enough resources to allocate the device path node, then EFI_OUT_OF_RESOURCES is returned.
923 Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of DevicePath are
924 initialized to describe the NVM Express namespace specified by NamespaceId, and EFI_SUCCESS is returned.
926 @param[in] This A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
927 @param[in] NamespaceId The NVM Express namespace ID for which a device path node is to be
928 allocated and built. Caller must set the NamespaceId to zero if the
929 device path node will contain a valid UUID.
930 @param[in,out] DevicePath A pointer to a single device path node that describes the NVM Express
931 namespace specified by NamespaceId. This function is responsible for
932 allocating the buffer DevicePath with the boot service AllocatePool().
933 It is the caller's responsibility to free DevicePath when the caller
934 is finished with DevicePath.
935 @retval EFI_SUCCESS The device path node that describes the NVM Express namespace specified
936 by NamespaceId was allocated and returned in DevicePath.
937 @retval EFI_NOT_FOUND The NamespaceId is not valid.
938 @retval EFI_INVALID_PARAMETER DevicePath is NULL.
939 @retval EFI_OUT_OF_RESOURCES There are not enough resources to allocate the DevicePath node.
944 NvmExpressBuildDevicePath (
945 IN EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*This
,
946 IN UINT32 NamespaceId
,
947 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
950 NVME_NAMESPACE_DEVICE_PATH
*Node
;
951 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
953 NVME_ADMIN_NAMESPACE_DATA
*NamespaceData
;
956 // Validate parameters
958 if ((This
== NULL
) || (DevicePath
== NULL
)) {
959 return EFI_INVALID_PARAMETER
;
962 Status
= EFI_SUCCESS
;
963 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (This
);
966 // Check NamespaceId is valid or not.
968 if ((NamespaceId
== 0) ||
969 (NamespaceId
> Private
->ControllerData
->Nn
)) {
970 return EFI_NOT_FOUND
;
973 Node
= (NVME_NAMESPACE_DEVICE_PATH
*)AllocateZeroPool (sizeof (NVME_NAMESPACE_DEVICE_PATH
));
975 return EFI_OUT_OF_RESOURCES
;
978 Node
->Header
.Type
= MESSAGING_DEVICE_PATH
;
979 Node
->Header
.SubType
= MSG_NVME_NAMESPACE_DP
;
980 SetDevicePathNodeLength (&Node
->Header
, sizeof (NVME_NAMESPACE_DEVICE_PATH
));
981 Node
->NamespaceId
= NamespaceId
;
984 // Allocate a buffer for Identify Namespace data.
986 NamespaceData
= NULL
;
987 NamespaceData
= AllocateZeroPool(sizeof (NVME_ADMIN_NAMESPACE_DATA
));
988 if(NamespaceData
== NULL
) {
989 Status
= EFI_OUT_OF_RESOURCES
;
994 // Get UUID from specified Identify Namespace data.
996 Status
= NvmeIdentifyNamespace (
999 (VOID
*)NamespaceData
1002 if (EFI_ERROR(Status
)) {
1006 Node
->NamespaceUuid
= NamespaceData
->Eui64
;
1008 *DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*)Node
;
1011 if(NamespaceData
!= NULL
) {
1012 FreePool (NamespaceData
);
1015 if (EFI_ERROR (Status
)) {