2 NvmExpressDxe driver is used to manage non-volatile memory subsystem which follows
3 NVM Express specification.
5 Copyright (c) 2013 - 2016, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "NvmExpress.h"
19 // NVM Express Driver Binding Protocol Instance
21 EFI_DRIVER_BINDING_PROTOCOL gNvmExpressDriverBinding
= {
22 NvmExpressDriverBindingSupported
,
23 NvmExpressDriverBindingStart
,
24 NvmExpressDriverBindingStop
,
31 // NVM Express EFI Driver Supported EFI Version Protocol Instance
33 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL gNvmExpressDriverSupportedEfiVersion
= {
34 sizeof (EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
), // Size of Protocol structure.
35 0 // Version number to be filled at start up.
39 // Template for NVM Express Pass Thru Mode data structure.
41 GLOBAL_REMOVE_IF_UNREFERENCED EFI_NVM_EXPRESS_PASS_THRU_MODE gEfiNvmExpressPassThruMode
= {
42 EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_PHYSICAL
| EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_LOGICAL
| EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_CMD_SET_NVM
,
48 Check if the specified Nvm Express device namespace is active, and create child handles
49 for them with BlockIo and DiskInfo protocol instances.
51 @param[in] Private The pointer to the NVME_CONTROLLER_PRIVATE_DATA data structure.
52 @param[in] NamespaceId The NVM Express namespace ID for which a device path node is to be
53 allocated and built. Caller must set the NamespaceId to zero if the
54 device path node will contain a valid UUID.
56 @retval EFI_SUCCESS All the namespaces in the device are successfully enumerated.
57 @return Others Some error occurs when enumerating the namespaces.
61 EnumerateNvmeDevNamespace (
62 IN NVME_CONTROLLER_PRIVATE_DATA
*Private
,
66 NVME_ADMIN_NAMESPACE_DATA
*NamespaceData
;
67 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePathNode
;
68 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
69 EFI_HANDLE DeviceHandle
;
70 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
71 EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
;
72 NVME_DEVICE_PRIVATE_DATA
*Device
;
78 NewDevicePathNode
= NULL
;
83 // Allocate a buffer for Identify Namespace data
85 NamespaceData
= AllocateZeroPool(sizeof (NVME_ADMIN_NAMESPACE_DATA
));
86 if(NamespaceData
== NULL
) {
87 return EFI_OUT_OF_RESOURCES
;
90 ParentDevicePath
= Private
->ParentDevicePath
;
94 Status
= NvmeIdentifyNamespace (
99 if (EFI_ERROR(Status
)) {
103 // Validate Namespace
105 if (NamespaceData
->Ncap
== 0) {
106 Status
= EFI_DEVICE_ERROR
;
109 // allocate device private data for each discovered namespace
111 Device
= AllocateZeroPool(sizeof(NVME_DEVICE_PRIVATE_DATA
));
112 if (Device
== NULL
) {
113 Status
= EFI_OUT_OF_RESOURCES
;
118 // Initialize SSD namespace instance data
120 Device
->Signature
= NVME_DEVICE_PRIVATE_DATA_SIGNATURE
;
121 Device
->NamespaceId
= NamespaceId
;
122 Device
->NamespaceUuid
= NamespaceData
->Eui64
;
124 Device
->ControllerHandle
= Private
->ControllerHandle
;
125 Device
->DriverBindingHandle
= Private
->DriverBindingHandle
;
126 Device
->Controller
= Private
;
129 // Build BlockIo media structure
131 Device
->Media
.MediaId
= 0;
132 Device
->Media
.RemovableMedia
= FALSE
;
133 Device
->Media
.MediaPresent
= TRUE
;
134 Device
->Media
.LogicalPartition
= FALSE
;
135 Device
->Media
.ReadOnly
= FALSE
;
136 Device
->Media
.WriteCaching
= FALSE
;
138 Flbas
= NamespaceData
->Flbas
;
139 LbaFmtIdx
= Flbas
& 0xF;
140 Lbads
= NamespaceData
->LbaFormat
[LbaFmtIdx
].Lbads
;
141 Device
->Media
.BlockSize
= (UINT32
)1 << Lbads
;
143 Device
->Media
.LastBlock
= NamespaceData
->Nsze
- 1;
144 Device
->Media
.LogicalBlocksPerPhysicalBlock
= 1;
145 Device
->Media
.LowestAlignedLba
= 1;
148 // Create BlockIo Protocol instance
150 Device
->BlockIo
.Revision
= EFI_BLOCK_IO_PROTOCOL_REVISION2
;
151 Device
->BlockIo
.Media
= &Device
->Media
;
152 Device
->BlockIo
.Reset
= NvmeBlockIoReset
;
153 Device
->BlockIo
.ReadBlocks
= NvmeBlockIoReadBlocks
;
154 Device
->BlockIo
.WriteBlocks
= NvmeBlockIoWriteBlocks
;
155 Device
->BlockIo
.FlushBlocks
= NvmeBlockIoFlushBlocks
;
158 // Create StorageSecurityProtocol Instance
160 Device
->StorageSecurity
.ReceiveData
= NvmeStorageSecurityReceiveData
;
161 Device
->StorageSecurity
.SendData
= NvmeStorageSecuritySendData
;
164 // Create DiskInfo Protocol instance
166 CopyMem (&Device
->NamespaceData
, NamespaceData
, sizeof (NVME_ADMIN_NAMESPACE_DATA
));
167 InitializeDiskInfo (Device
);
170 // Create a Nvm Express Namespace Device Path Node
172 Status
= Private
->Passthru
.BuildDevicePath (
178 if (EFI_ERROR(Status
)) {
183 // Append the SSD node to the controller's device path
185 DevicePath
= AppendDevicePathNode (ParentDevicePath
, NewDevicePathNode
);
186 if (DevicePath
== NULL
) {
187 Status
= EFI_OUT_OF_RESOURCES
;
192 RemainingDevicePath
= DevicePath
;
193 Status
= gBS
->LocateDevicePath (&gEfiDevicePathProtocolGuid
, &RemainingDevicePath
, &DeviceHandle
);
194 if (!EFI_ERROR (Status
) && (DeviceHandle
!= NULL
) && IsDevicePathEnd(RemainingDevicePath
)) {
195 Status
= EFI_ALREADY_STARTED
;
196 FreePool (DevicePath
);
200 Device
->DevicePath
= DevicePath
;
203 // Make sure the handle is NULL so we create a new handle
205 Device
->DeviceHandle
= NULL
;
207 Status
= gBS
->InstallMultipleProtocolInterfaces (
208 &Device
->DeviceHandle
,
209 &gEfiDevicePathProtocolGuid
,
211 &gEfiBlockIoProtocolGuid
,
213 &gEfiDiskInfoProtocolGuid
,
218 if(EFI_ERROR(Status
)) {
223 // Check if the NVMe controller supports the Security Send and Security Receive commands
225 if ((Private
->ControllerData
->Oacs
& SECURITY_SEND_RECEIVE_SUPPORTED
) != 0) {
226 Status
= gBS
->InstallProtocolInterface (
227 &Device
->DeviceHandle
,
228 &gEfiStorageSecurityCommandProtocolGuid
,
229 EFI_NATIVE_INTERFACE
,
230 &Device
->StorageSecurity
232 if(EFI_ERROR(Status
)) {
233 gBS
->UninstallMultipleProtocolInterfaces (
234 &Device
->DeviceHandle
,
235 &gEfiDevicePathProtocolGuid
,
237 &gEfiBlockIoProtocolGuid
,
239 &gEfiDiskInfoProtocolGuid
,
248 Private
->ControllerHandle
,
249 &gEfiNvmExpressPassThruProtocolGuid
,
250 (VOID
**) &Private
->Passthru
,
251 Private
->DriverBindingHandle
,
252 Device
->DeviceHandle
,
253 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
257 // Dump NvmExpress Identify Namespace Data
259 DEBUG ((EFI_D_INFO
, " == NVME IDENTIFY NAMESPACE [%d] DATA ==\n", NamespaceId
));
260 DEBUG ((EFI_D_INFO
, " NSZE : 0x%x\n", NamespaceData
->Nsze
));
261 DEBUG ((EFI_D_INFO
, " NCAP : 0x%x\n", NamespaceData
->Ncap
));
262 DEBUG ((EFI_D_INFO
, " NUSE : 0x%x\n", NamespaceData
->Nuse
));
263 DEBUG ((EFI_D_INFO
, " LBAF0.LBADS : 0x%x\n", (NamespaceData
->LbaFormat
[0].Lbads
)));
266 // Build controller name for Component Name (2) protocol.
268 UnicodeSPrintAsciiFormat (Device
->ModelName
, sizeof (Device
->ModelName
), "%a-%a-%x", Private
->ControllerData
->Sn
, Private
->ControllerData
->Mn
, NamespaceData
->Eui64
);
272 gNvmExpressComponentName
.SupportedLanguages
,
273 &Device
->ControllerNameTable
,
280 gNvmExpressComponentName2
.SupportedLanguages
,
281 &Device
->ControllerNameTable
,
288 if(NamespaceData
!= NULL
) {
289 FreePool (NamespaceData
);
292 if (NewDevicePathNode
!= NULL
) {
293 FreePool (NewDevicePathNode
);
296 if(EFI_ERROR(Status
) && (Device
!= NULL
) && (Device
->DevicePath
!= NULL
)) {
297 FreePool (Device
->DevicePath
);
299 if(EFI_ERROR(Status
) && (Device
!= NULL
)) {
306 Discover all Nvm Express device namespaces, and create child handles for them with BlockIo
307 and DiskInfo protocol instances.
309 @param[in] Private The pointer to the NVME_CONTROLLER_PRIVATE_DATA data structure.
311 @retval EFI_SUCCESS All the namespaces in the device are successfully enumerated.
312 @return Others Some error occurs when enumerating the namespaces.
316 DiscoverAllNamespaces (
317 IN NVME_CONTROLLER_PRIVATE_DATA
*Private
322 EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*Passthru
;
324 NamespaceId
= 0xFFFFFFFF;
325 Passthru
= &Private
->Passthru
;
328 Status
= Passthru
->GetNextNamespace (
330 (UINT32
*)&NamespaceId
333 if (EFI_ERROR (Status
)) {
337 Status
= EnumerateNvmeDevNamespace (
342 if (EFI_ERROR(Status
)) {
351 Unregisters a Nvm Express device namespace.
353 This function removes the protocols installed on the controller handle and
354 frees the resources allocated for the namespace.
356 @param This The pointer to EFI_DRIVER_BINDING_PROTOCOL instance.
357 @param Controller The controller handle of the namespace.
358 @param Handle The child handle.
360 @retval EFI_SUCCESS The namespace is successfully unregistered.
361 @return Others Some error occurs when unregistering the namespace.
365 UnregisterNvmeNamespace (
366 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
367 IN EFI_HANDLE Controller
,
372 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
373 NVME_DEVICE_PRIVATE_DATA
*Device
;
374 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
375 EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
*StorageSecurity
;
379 Status
= gBS
->OpenProtocol (
381 &gEfiBlockIoProtocolGuid
,
383 This
->DriverBindingHandle
,
385 EFI_OPEN_PROTOCOL_GET_PROTOCOL
387 if (EFI_ERROR (Status
)) {
391 Device
= NVME_DEVICE_PRIVATE_DATA_FROM_BLOCK_IO (BlockIo
);
392 Private
= Device
->Controller
;
395 // Close the child handle
399 &gEfiNvmExpressPassThruProtocolGuid
,
400 This
->DriverBindingHandle
,
405 // The Nvm Express driver installs the BlockIo and DiskInfo in the DriverBindingStart().
406 // Here should uninstall both of them.
408 Status
= gBS
->UninstallMultipleProtocolInterfaces (
410 &gEfiDevicePathProtocolGuid
,
412 &gEfiBlockIoProtocolGuid
,
414 &gEfiDiskInfoProtocolGuid
,
419 if (EFI_ERROR (Status
)) {
422 &gEfiNvmExpressPassThruProtocolGuid
,
423 (VOID
**) &Private
->Passthru
,
424 This
->DriverBindingHandle
,
426 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
432 // If Storage Security Command Protocol is installed, then uninstall this protocol.
434 Status
= gBS
->OpenProtocol (
436 &gEfiStorageSecurityCommandProtocolGuid
,
437 (VOID
**) &StorageSecurity
,
438 This
->DriverBindingHandle
,
440 EFI_OPEN_PROTOCOL_GET_PROTOCOL
443 if (!EFI_ERROR (Status
)) {
444 Status
= gBS
->UninstallProtocolInterface (
446 &gEfiStorageSecurityCommandProtocolGuid
,
447 &Device
->StorageSecurity
449 if (EFI_ERROR (Status
)) {
452 &gEfiNvmExpressPassThruProtocolGuid
,
453 (VOID
**) &Private
->Passthru
,
454 This
->DriverBindingHandle
,
456 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
462 if(Device
->DevicePath
!= NULL
) {
463 FreePool (Device
->DevicePath
);
466 if (Device
->ControllerNameTable
!= NULL
) {
467 FreeUnicodeStringTable (Device
->ControllerNameTable
);
476 Tests to see if this driver supports a given controller. If a child device is provided,
477 it further tests to see if this driver supports creating a handle for the specified child device.
479 This function checks to see if the driver specified by This supports the device specified by
480 ControllerHandle. Drivers will typically use the device path attached to
481 ControllerHandle and/or the services from the bus I/O abstraction attached to
482 ControllerHandle to determine if the driver supports ControllerHandle. This function
483 may be called many times during platform initialization. In order to reduce boot times, the tests
484 performed by this function must be very small, and take as little time as possible to execute. This
485 function must not change the state of any hardware devices, and this function must be aware that the
486 device specified by ControllerHandle may already be managed by the same driver or a
487 different driver. This function must match its calls to AllocatePages() with FreePages(),
488 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
489 Since ControllerHandle may have been previously started by the same driver, if a protocol is
490 already in the opened state, then it must not be closed with CloseProtocol(). This is required
491 to guarantee the state of ControllerHandle is not modified by this function.
493 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
494 @param[in] ControllerHandle The handle of the controller to test. This handle
495 must support a protocol interface that supplies
496 an I/O abstraction to the driver.
497 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
498 parameter is ignored by device drivers, and is optional for bus
499 drivers. For bus drivers, if this parameter is not NULL, then
500 the bus driver must determine if the bus controller specified
501 by ControllerHandle and the child controller specified
502 by RemainingDevicePath are both supported by this
505 @retval EFI_SUCCESS The device specified by ControllerHandle and
506 RemainingDevicePath is supported by the driver specified by This.
507 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
508 RemainingDevicePath is already being managed by the driver
510 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
511 RemainingDevicePath is already being managed by a different
512 driver or an application that requires exclusive access.
513 Currently not implemented.
514 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and
515 RemainingDevicePath is not supported by the driver specified by This.
519 NvmExpressDriverBindingSupported (
520 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
521 IN EFI_HANDLE Controller
,
522 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
526 EFI_DEV_PATH_PTR DevicePathNode
;
527 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
528 EFI_PCI_IO_PROTOCOL
*PciIo
;
532 // Check whether device path is valid
534 if (RemainingDevicePath
!= NULL
) {
536 // Check if RemainingDevicePath is the End of Device Path Node,
537 // if yes, go on checking other conditions
539 if (!IsDevicePathEnd (RemainingDevicePath
)) {
541 // If RemainingDevicePath isn't the End of Device Path Node,
542 // check its validation
544 DevicePathNode
.DevPath
= RemainingDevicePath
;
546 if ((DevicePathNode
.DevPath
->Type
!= MESSAGING_DEVICE_PATH
) ||
547 (DevicePathNode
.DevPath
->SubType
!= MSG_NVME_NAMESPACE_DP
) ||
548 (DevicePathNodeLength(DevicePathNode
.DevPath
) != sizeof(NVME_NAMESPACE_DEVICE_PATH
))) {
549 return EFI_UNSUPPORTED
;
555 // Open the EFI Device Path protocol needed to perform the supported test
557 Status
= gBS
->OpenProtocol (
559 &gEfiDevicePathProtocolGuid
,
560 (VOID
**) &ParentDevicePath
,
561 This
->DriverBindingHandle
,
563 EFI_OPEN_PROTOCOL_BY_DRIVER
565 if (Status
== EFI_ALREADY_STARTED
) {
569 if (EFI_ERROR (Status
)) {
574 // Close protocol, don't use device path protocol in the Support() function
578 &gEfiDevicePathProtocolGuid
,
579 This
->DriverBindingHandle
,
584 // Attempt to Open PCI I/O Protocol
586 Status
= gBS
->OpenProtocol (
588 &gEfiPciIoProtocolGuid
,
590 This
->DriverBindingHandle
,
592 EFI_OPEN_PROTOCOL_BY_DRIVER
594 if (Status
== EFI_ALREADY_STARTED
) {
598 if (EFI_ERROR (Status
)) {
603 // Now further check the PCI header: Base class (offset 0x0B) and Sub Class (offset 0x0A).
604 // This controller should be a Nvm Express controller.
606 Status
= PciIo
->Pci
.Read (
609 PCI_CLASSCODE_OFFSET
,
613 if (EFI_ERROR (Status
)) {
618 // Examine Nvm Express controller PCI Configuration table fields
620 if ((ClassCode
[0] != PCI_IF_NVMHCI
) || (ClassCode
[1] != PCI_CLASS_MASS_STORAGE_NVM
) || (ClassCode
[2] != PCI_CLASS_MASS_STORAGE
)) {
621 Status
= EFI_UNSUPPORTED
;
627 &gEfiPciIoProtocolGuid
,
628 This
->DriverBindingHandle
,
637 Starts a device controller or a bus controller.
639 The Start() function is designed to be invoked from the EFI boot service ConnectController().
640 As a result, much of the error checking on the parameters to Start() has been moved into this
641 common boot service. It is legal to call Start() from other locations,
642 but the following calling restrictions must be followed or the system behavior will not be deterministic.
643 1. ControllerHandle must be a valid EFI_HANDLE.
644 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
645 EFI_DEVICE_PATH_PROTOCOL.
646 3. Prior to calling Start(), the Supported() function for the driver specified by This must
647 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
649 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
650 @param[in] ControllerHandle The handle of the controller to start. This handle
651 must support a protocol interface that supplies
652 an I/O abstraction to the driver.
653 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
654 parameter is ignored by device drivers, and is optional for bus
655 drivers. For a bus driver, if this parameter is NULL, then handles
656 for all the children of Controller are created by this driver.
657 If this parameter is not NULL and the first Device Path Node is
658 not the End of Device Path Node, then only the handle for the
659 child device specified by the first Device Path Node of
660 RemainingDevicePath is created by this driver.
661 If the first Device Path Node of RemainingDevicePath is
662 the End of Device Path Node, no child handle is created by this
665 @retval EFI_SUCCESS The device was started.
666 @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
667 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
668 @retval Others The driver failded to start the device.
673 NvmExpressDriverBindingStart (
674 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
675 IN EFI_HANDLE Controller
,
676 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
680 EFI_PCI_IO_PROTOCOL
*PciIo
;
681 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
682 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
684 EFI_PHYSICAL_ADDRESS MappedAddr
;
686 EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*Passthru
;
688 DEBUG ((EFI_D_INFO
, "NvmExpressDriverBindingStart: start\n"));
692 ParentDevicePath
= NULL
;
694 Status
= gBS
->OpenProtocol (
696 &gEfiDevicePathProtocolGuid
,
697 (VOID
**) &ParentDevicePath
,
698 This
->DriverBindingHandle
,
700 EFI_OPEN_PROTOCOL_BY_DRIVER
702 if ((EFI_ERROR (Status
)) && (Status
!= EFI_ALREADY_STARTED
)) {
706 Status
= gBS
->OpenProtocol (
708 &gEfiPciIoProtocolGuid
,
710 This
->DriverBindingHandle
,
712 EFI_OPEN_PROTOCOL_BY_DRIVER
715 if (EFI_ERROR (Status
) && (Status
!= EFI_ALREADY_STARTED
)) {
720 // Check EFI_ALREADY_STARTED to reuse the original NVME_CONTROLLER_PRIVATE_DATA.
722 if (Status
!= EFI_ALREADY_STARTED
) {
723 Private
= AllocateZeroPool (sizeof (NVME_CONTROLLER_PRIVATE_DATA
));
725 if (Private
== NULL
) {
726 DEBUG ((EFI_D_ERROR
, "NvmExpressDriverBindingStart: allocating pool for Nvme Private Data failed!\n"));
727 Status
= EFI_OUT_OF_RESOURCES
;
732 // 4 x 4kB aligned buffers will be carved out of this buffer.
733 // 1st 4kB boundary is the start of the admin submission queue.
734 // 2nd 4kB boundary is the start of the admin completion queue.
735 // 3rd 4kB boundary is the start of I/O submission queue #1.
736 // 4th 4kB boundary is the start of I/O completion queue #1.
738 // Allocate 4 pages of memory, then map it for bus master read and write.
740 Status
= PciIo
->AllocateBuffer (
745 (VOID
**)&Private
->Buffer
,
748 if (EFI_ERROR (Status
)) {
752 Bytes
= EFI_PAGES_TO_SIZE (4);
753 Status
= PciIo
->Map (
755 EfiPciIoOperationBusMasterCommonBuffer
,
762 if (EFI_ERROR (Status
) || (Bytes
!= EFI_PAGES_TO_SIZE (4))) {
766 Private
->BufferPciAddr
= (UINT8
*)(UINTN
)MappedAddr
;
767 ZeroMem (Private
->Buffer
, EFI_PAGES_TO_SIZE (4));
769 Private
->Signature
= NVME_CONTROLLER_PRIVATE_DATA_SIGNATURE
;
770 Private
->ControllerHandle
= Controller
;
771 Private
->ImageHandle
= This
->DriverBindingHandle
;
772 Private
->DriverBindingHandle
= This
->DriverBindingHandle
;
773 Private
->PciIo
= PciIo
;
774 Private
->ParentDevicePath
= ParentDevicePath
;
775 Private
->Passthru
.Mode
= &Private
->PassThruMode
;
776 Private
->Passthru
.PassThru
= NvmExpressPassThru
;
777 Private
->Passthru
.GetNextNamespace
= NvmExpressGetNextNamespace
;
778 Private
->Passthru
.BuildDevicePath
= NvmExpressBuildDevicePath
;
779 Private
->Passthru
.GetNamespace
= NvmExpressGetNamespace
;
780 CopyMem (&Private
->PassThruMode
, &gEfiNvmExpressPassThruMode
, sizeof (EFI_NVM_EXPRESS_PASS_THRU_MODE
));
782 Status
= NvmeControllerInit (Private
);
783 if (EFI_ERROR(Status
)) {
787 Status
= gBS
->InstallMultipleProtocolInterfaces (
789 &gEfiNvmExpressPassThruProtocolGuid
,
793 if (EFI_ERROR (Status
)) {
797 Status
= gBS
->OpenProtocol (
799 &gEfiNvmExpressPassThruProtocolGuid
,
801 This
->DriverBindingHandle
,
803 EFI_OPEN_PROTOCOL_GET_PROTOCOL
805 if (EFI_ERROR (Status
)) {
809 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (Passthru
);
812 if (RemainingDevicePath
== NULL
) {
814 // Enumerate all NVME namespaces in the controller
816 Status
= DiscoverAllNamespaces (
820 } else if (!IsDevicePathEnd (RemainingDevicePath
)) {
822 // Enumerate the specified NVME namespace
824 Status
= Private
->Passthru
.GetNamespace (
830 if (!EFI_ERROR (Status
)) {
831 Status
= EnumerateNvmeDevNamespace (
838 DEBUG ((EFI_D_INFO
, "NvmExpressDriverBindingStart: end successfully\n"));
842 if ((Private
!= NULL
) && (Private
->Mapping
!= NULL
)) {
843 PciIo
->Unmap (PciIo
, Private
->Mapping
);
846 if ((Private
!= NULL
) && (Private
->Buffer
!= NULL
)) {
847 PciIo
->FreeBuffer (PciIo
, 4, Private
->Buffer
);
850 if (Private
!= NULL
) {
856 &gEfiPciIoProtocolGuid
,
857 This
->DriverBindingHandle
,
863 &gEfiDevicePathProtocolGuid
,
864 This
->DriverBindingHandle
,
868 DEBUG ((EFI_D_INFO
, "NvmExpressDriverBindingStart: end with %r\n", Status
));
875 Stops a device controller or a bus controller.
877 The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
878 As a result, much of the error checking on the parameters to Stop() has been moved
879 into this common boot service. It is legal to call Stop() from other locations,
880 but the following calling restrictions must be followed or the system behavior will not be deterministic.
881 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
882 same driver's Start() function.
883 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
884 EFI_HANDLE. In addition, all of these handles must have been created in this driver's
885 Start() function, and the Start() function must have called OpenProtocol() on
886 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
888 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
889 @param[in] ControllerHandle A handle to the device being stopped. The handle must
890 support a bus specific I/O protocol for the driver
891 to use to stop the device.
892 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
893 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
894 if NumberOfChildren is 0.
896 @retval EFI_SUCCESS The device was stopped.
897 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
902 NvmExpressDriverBindingStop (
903 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
904 IN EFI_HANDLE Controller
,
905 IN UINTN NumberOfChildren
,
906 IN EFI_HANDLE
*ChildHandleBuffer
910 BOOLEAN AllChildrenStopped
;
912 NVME_CONTROLLER_PRIVATE_DATA
*Private
;
913 EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
*PassThru
;
915 if (NumberOfChildren
== 0) {
916 Status
= gBS
->OpenProtocol (
918 &gEfiNvmExpressPassThruProtocolGuid
,
920 This
->DriverBindingHandle
,
922 EFI_OPEN_PROTOCOL_GET_PROTOCOL
925 if (!EFI_ERROR (Status
)) {
926 Private
= NVME_CONTROLLER_PRIVATE_DATA_FROM_PASS_THRU (PassThru
);
927 gBS
->UninstallMultipleProtocolInterfaces (
929 &gEfiNvmExpressPassThruProtocolGuid
,
934 if (Private
->Mapping
!= NULL
) {
935 Private
->PciIo
->Unmap (Private
->PciIo
, Private
->Mapping
);
938 if (Private
->Buffer
!= NULL
) {
939 Private
->PciIo
->FreeBuffer (Private
->PciIo
, 4, Private
->Buffer
);
942 FreePool (Private
->ControllerData
);
948 &gEfiPciIoProtocolGuid
,
949 This
->DriverBindingHandle
,
954 &gEfiDevicePathProtocolGuid
,
955 This
->DriverBindingHandle
,
961 AllChildrenStopped
= TRUE
;
963 for (Index
= 0; Index
< NumberOfChildren
; Index
++) {
964 Status
= UnregisterNvmeNamespace (This
, Controller
, ChildHandleBuffer
[Index
]);
965 if (EFI_ERROR (Status
)) {
966 AllChildrenStopped
= FALSE
;
970 if (!AllChildrenStopped
) {
971 return EFI_DEVICE_ERROR
;
978 This is the unload handle for the NVM Express driver.
980 Disconnect the driver specified by ImageHandle from the NVMe device in the handle database.
981 Uninstall all the protocols installed in the driver.
983 @param[in] ImageHandle The drivers' driver image.
985 @retval EFI_SUCCESS The image is unloaded.
986 @retval Others Failed to unload the image.
992 IN EFI_HANDLE ImageHandle
996 EFI_HANDLE
*DeviceHandleBuffer
;
997 UINTN DeviceHandleCount
;
999 EFI_COMPONENT_NAME_PROTOCOL
*ComponentName
;
1000 EFI_COMPONENT_NAME2_PROTOCOL
*ComponentName2
;
1003 // Get the list of the device handles managed by this driver.
1004 // If there is an error getting the list, then means the driver
1005 // doesn't manage any device. At this way, we would only close
1006 // those protocols installed at image handle.
1008 DeviceHandleBuffer
= NULL
;
1009 Status
= gBS
->LocateHandleBuffer (
1011 &gEfiNvmExpressPassThruProtocolGuid
,
1017 if (!EFI_ERROR (Status
)) {
1019 // Disconnect the driver specified by ImageHandle from all
1020 // the devices in the handle database.
1022 for (Index
= 0; Index
< DeviceHandleCount
; Index
++) {
1023 Status
= gBS
->DisconnectController (
1024 DeviceHandleBuffer
[Index
],
1028 if (EFI_ERROR (Status
)) {
1035 // Uninstall all the protocols installed in the driver entry point
1037 Status
= gBS
->UninstallMultipleProtocolInterfaces (
1039 &gEfiDriverBindingProtocolGuid
,
1040 &gNvmExpressDriverBinding
,
1041 &gEfiDriverSupportedEfiVersionProtocolGuid
,
1042 &gNvmExpressDriverSupportedEfiVersion
,
1046 if (EFI_ERROR (Status
)) {
1051 // Note we have to one by one uninstall the following protocols.
1052 // It's because some of them are optionally installed based on
1053 // the following PCD settings.
1054 // gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable
1055 // gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable
1056 // gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable
1057 // gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable
1059 Status
= gBS
->HandleProtocol (
1061 &gEfiComponentNameProtocolGuid
,
1062 (VOID
**) &ComponentName
1064 if (!EFI_ERROR (Status
)) {
1065 gBS
->UninstallProtocolInterface (
1067 &gEfiComponentNameProtocolGuid
,
1072 Status
= gBS
->HandleProtocol (
1074 &gEfiComponentName2ProtocolGuid
,
1075 (VOID
**) &ComponentName2
1077 if (!EFI_ERROR (Status
)) {
1078 gBS
->UninstallProtocolInterface (
1080 &gEfiComponentName2ProtocolGuid
,
1085 Status
= EFI_SUCCESS
;
1089 // Free the buffer containing the list of handles from the handle database
1091 if (DeviceHandleBuffer
!= NULL
) {
1092 gBS
->FreePool (DeviceHandleBuffer
);
1098 The entry point for Nvm Express driver, used to install Nvm Express driver on the ImageHandle.
1100 @param ImageHandle The firmware allocated handle for this driver image.
1101 @param SystemTable Pointer to the EFI system table.
1103 @retval EFI_SUCCESS Driver loaded.
1104 @retval other Driver not loaded.
1109 NvmExpressDriverEntry (
1110 IN EFI_HANDLE ImageHandle
,
1111 IN EFI_SYSTEM_TABLE
*SystemTable
1116 Status
= EfiLibInstallDriverBindingComponentName2 (
1119 &gNvmExpressDriverBinding
,
1121 &gNvmExpressComponentName
,
1122 &gNvmExpressComponentName2
1124 ASSERT_EFI_ERROR (Status
);
1127 // Install EFI Driver Supported EFI Version Protocol required for
1128 // EFI drivers that are on PCI and other plug in cards.
1130 gNvmExpressDriverSupportedEfiVersion
.FirmwareVersion
= 0x00020028;
1131 Status
= gBS
->InstallMultipleProtocolInterfaces (
1133 &gEfiDriverSupportedEfiVersionProtocolGuid
,
1134 &gNvmExpressDriverSupportedEfiVersion
,
1137 ASSERT_EFI_ERROR (Status
);