2 Entrypoint of Opal UEFI Driver and contains all the logic to
3 register for new Opal device instances.
5 Copyright (c) 2016 - 2018, 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 // This UEFI driver consumes EFI_STORAGE_SECURITY_PROTOCOL instances and installs an
17 // HII GUI to manage Opal features if the device is Opal capable
18 // If the Opal device is being managed by the UEFI Driver, it shall provide a popup
19 // window during boot requesting a user password
21 #include "OpalDriver.h"
24 EFI_GUID mOpalDeviceAtaGuid
= OPAL_DEVICE_ATA_GUID
;
25 EFI_GUID mOpalDeviceNvmeGuid
= OPAL_DEVICE_NVME_GUID
;
27 BOOLEAN mOpalEndOfDxe
= FALSE
;
28 OPAL_REQUEST_VARIABLE
*mOpalRequestVariable
= NULL
;
29 UINTN mOpalRequestVariableSize
= 0;
30 CHAR16 mPopUpString
[100];
34 S3_BOOT_SCRIPT_LIB_WIDTH Width
;
35 } OPAL_HC_PCI_REGISTER_SAVE
;
38 // To unlock the Intel SATA controller at S3 Resume, restored the following registers.
40 const OPAL_HC_PCI_REGISTER_SAVE mSataHcRegisterSaveTemplate
[] = {
41 {0x9, S3BootScriptWidthUint8
},
42 {0x10, S3BootScriptWidthUint32
},
43 {0x14, S3BootScriptWidthUint32
},
44 {0x18, S3BootScriptWidthUint32
},
45 {0x1C, S3BootScriptWidthUint32
},
46 {0x20, S3BootScriptWidthUint32
},
47 {0x24, S3BootScriptWidthUint32
},
48 {0x3c, S3BootScriptWidthUint8
},
49 {0x3d, S3BootScriptWidthUint8
},
50 {0x40, S3BootScriptWidthUint16
},
51 {0x42, S3BootScriptWidthUint16
},
52 {0x92, S3BootScriptWidthUint16
},
53 {0x94, S3BootScriptWidthUint32
},
54 {0x9C, S3BootScriptWidthUint32
},
55 {0x4, S3BootScriptWidthUint16
},
58 OPAL_DRIVER mOpalDriver
;
63 EFI_DRIVER_BINDING_PROTOCOL gOpalDriverBinding
= {
64 OpalEfiDriverBindingSupported
,
65 OpalEfiDriverBindingStart
,
66 OpalEfiDriverBindingStop
,
74 The function determines the available actions for the OPAL_DISK provided.
76 @param[in] SupportedAttributes The supported attributes for the device.
77 @param[in] LockingFeature The locking status for the device.
78 @param[in] OwnerShip The ownership for the device.
79 @param[out] AvalDiskActions Pointer to fill-out with appropriate disk actions.
84 OpalSupportGetAvailableActions(
85 IN OPAL_DISK_SUPPORT_ATTRIBUTE
*SupportedAttributes
,
86 IN TCG_LOCKING_FEATURE_DESCRIPTOR
*LockingFeature
,
88 OUT OPAL_DISK_ACTIONS
*AvalDiskActions
91 BOOLEAN ExistingPassword
;
93 NULL_CHECK(AvalDiskActions
);
95 AvalDiskActions
->AdminPass
= 1;
96 AvalDiskActions
->UserPass
= 0;
97 AvalDiskActions
->DisableUser
= 0;
98 AvalDiskActions
->Unlock
= 0;
101 // Revert is performed on locking sp, so only allow if locking sp is enabled
103 if (LockingFeature
->LockingEnabled
) {
104 AvalDiskActions
->Revert
= 1;
108 // Psid revert is available for any device with media encryption support or pyrite 2.0 type support.
110 if (SupportedAttributes
->PyriteSscV2
|| SupportedAttributes
->MediaEncryption
) {
113 // Only allow psid revert if media encryption is enabled or pyrite 2.0 type support..
114 // Otherwise, someone who steals a disk can psid revert the disk and the user Data is still
115 // intact and accessible
117 AvalDiskActions
->PsidRevert
= 1;
118 AvalDiskActions
->RevertKeepDataForced
= 0;
121 // Secure erase is performed by generating a new encryption key
122 // this is only available if encryption is supported
124 AvalDiskActions
->SecureErase
= 1;
126 AvalDiskActions
->PsidRevert
= 0;
127 AvalDiskActions
->SecureErase
= 0;
130 // If no media encryption is supported, then a revert (using password) will not
131 // erase the Data (since you can't generate a new encryption key)
133 AvalDiskActions
->RevertKeepDataForced
= 1;
136 if (LockingFeature
->Locked
) {
137 AvalDiskActions
->Unlock
= 1;
139 AvalDiskActions
->Unlock
= 0;
143 // Only allow user to set password if an admin password exists
145 ExistingPassword
= OpalUtilAdminPasswordExists(OwnerShip
, LockingFeature
);
146 AvalDiskActions
->UserPass
= ExistingPassword
;
149 // This will still show up even if there isn't a user, which is fine
151 AvalDiskActions
->DisableUser
= ExistingPassword
;
153 return TcgResultSuccess
;
157 Enable Opal Feature for the input device.
159 @param[in] Session The opal session for the opal device.
161 @param[in] MsidLength Msid Length
162 @param[in] Password Admin password
163 @param[in] PassLength Length of password in bytes
168 OpalSupportEnableOpalFeature (
169 IN OPAL_SESSION
*Session
,
171 IN UINT32 MsidLength
,
180 NULL_CHECK(Password
);
182 Ret
= OpalUtilSetAdminPasswordAsSid(
189 if (Ret
== TcgResultSuccess
) {
191 // Enable global locking range
193 Ret
= OpalUtilSetOpalLockingRange(
197 OPAL_LOCKING_SP_LOCKING_GLOBALRANGE
,
211 Update password for the Opal disk.
213 @param[in, out] OpalDisk The disk to update password.
214 @param[in] Password The input password.
215 @param[in] PasswordLength The input password length.
219 OpalSupportUpdatePassword (
220 IN OUT OPAL_DISK
*OpalDisk
,
222 IN UINT32 PasswordLength
225 CopyMem (OpalDisk
->Password
, Password
, PasswordLength
);
226 OpalDisk
->PasswordLength
= (UINT8
) PasswordLength
;
230 Extract device info from the device path.
232 @param[in] DevicePath Device path info for the device.
233 @param[out] DevInfoLength Device information length needed.
234 @param[out] DevInfo Device information extracted.
240 ExtractDeviceInfoFromDevicePath (
241 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
242 OUT UINT16
*DevInfoLength
,
243 OUT OPAL_DEVICE_COMMON
*DevInfo OPTIONAL
246 EFI_DEVICE_PATH_PROTOCOL
*TmpDevPath
;
247 EFI_DEVICE_PATH_PROTOCOL
*TmpDevPath2
;
248 PCI_DEVICE_PATH
*PciDevPath
;
251 OPAL_PCI_DEVICE
*PciDevice
;
252 OPAL_DEVICE_ATA
*DevInfoAta
;
253 OPAL_DEVICE_NVME
*DevInfoNvme
;
254 SATA_DEVICE_PATH
*SataDevPath
;
255 NVME_NAMESPACE_DEVICE_PATH
*NvmeDevPath
;
257 ASSERT (DevicePath
!= NULL
);
258 ASSERT (DevInfoLength
!= NULL
);
260 DeviceType
= OPAL_DEVICE_TYPE_UNKNOWN
;
263 TmpDevPath
= DevicePath
;
268 while (!IsDevicePathEnd (TmpDevPath
)) {
269 if (TmpDevPath
->Type
== MESSAGING_DEVICE_PATH
&& TmpDevPath
->SubType
== MSG_SATA_DP
) {
273 if (DevInfo
!= NULL
) {
274 SataDevPath
= (SATA_DEVICE_PATH
*) TmpDevPath
;
275 DevInfoAta
= (OPAL_DEVICE_ATA
*) DevInfo
;
276 DevInfoAta
->Port
= SataDevPath
->HBAPortNumber
;
277 DevInfoAta
->PortMultiplierPort
= SataDevPath
->PortMultiplierPortNumber
;
279 DeviceType
= OPAL_DEVICE_TYPE_ATA
;
280 *DevInfoLength
= sizeof (OPAL_DEVICE_ATA
);
282 } else if (TmpDevPath
->Type
== MESSAGING_DEVICE_PATH
&& TmpDevPath
->SubType
== MSG_NVME_NAMESPACE_DP
) {
286 if (DevInfo
!= NULL
) {
287 NvmeDevPath
= (NVME_NAMESPACE_DEVICE_PATH
*) TmpDevPath
;
288 DevInfoNvme
= (OPAL_DEVICE_NVME
*) DevInfo
;
289 DevInfoNvme
->NvmeNamespaceId
= NvmeDevPath
->NamespaceId
;
291 DeviceType
= OPAL_DEVICE_TYPE_NVME
;
292 *DevInfoLength
= sizeof (OPAL_DEVICE_NVME
);
295 TmpDevPath
= NextDevicePathNode (TmpDevPath
);
302 TmpDevPath
= DevicePath
;
303 TmpDevPath2
= NextDevicePathNode (DevicePath
);
304 while (!IsDevicePathEnd (TmpDevPath2
)) {
305 if (TmpDevPath
->Type
== HARDWARE_DEVICE_PATH
&& TmpDevPath
->SubType
== HW_PCI_DP
) {
306 PciDevPath
= (PCI_DEVICE_PATH
*) TmpDevPath
;
307 if ((TmpDevPath2
->Type
== MESSAGING_DEVICE_PATH
&& TmpDevPath2
->SubType
== MSG_NVME_NAMESPACE_DP
)||
308 (TmpDevPath2
->Type
== MESSAGING_DEVICE_PATH
&& TmpDevPath2
->SubType
== MSG_SATA_DP
)) {
309 if (DevInfo
!= NULL
) {
310 PciDevice
= &DevInfo
->Device
;
311 PciDevice
->Segment
= 0;
312 PciDevice
->Bus
= BusNum
;
313 PciDevice
->Device
= PciDevPath
->Device
;
314 PciDevice
->Function
= PciDevPath
->Function
;
317 if (DevInfo
!= NULL
) {
318 PciDevice
= (OPAL_PCI_DEVICE
*) ((UINTN
) DevInfo
+ *DevInfoLength
);
319 PciDevice
->Segment
= 0;
320 PciDevice
->Bus
= BusNum
;
321 PciDevice
->Device
= PciDevPath
->Device
;
322 PciDevice
->Function
= PciDevPath
->Function
;
324 *DevInfoLength
+= sizeof (OPAL_PCI_DEVICE
);
325 if (TmpDevPath2
->Type
== HARDWARE_DEVICE_PATH
&& TmpDevPath2
->SubType
== HW_PCI_DP
) {
326 BusNum
= PciRead8 (PCI_LIB_ADDRESS (BusNum
, PciDevPath
->Device
, PciDevPath
->Function
, PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET
));
331 TmpDevPath
= NextDevicePathNode (TmpDevPath
);
332 TmpDevPath2
= NextDevicePathNode (TmpDevPath2
);
335 ASSERT (DeviceType
!= OPAL_DEVICE_TYPE_UNKNOWN
);
340 Save boot script for ATA OPAL device.
342 @param[in] DevInfo Pointer to ATA Opal device information.
346 OpalDeviceAtaSaveBootScript (
347 IN OPAL_DEVICE_ATA
*DevInfo
357 S3_BOOT_SCRIPT_LIB_WIDTH Width
;
359 OPAL_HC_PCI_REGISTER_SAVE
*HcRegisterSaveListPtr
;
364 Bus
= DevInfo
->Device
.Bus
;
365 Device
= DevInfo
->Device
.Device
;
366 Function
= DevInfo
->Device
.Function
;
368 HcRegisterSaveListPtr
= (OPAL_HC_PCI_REGISTER_SAVE
*) mSataHcRegisterSaveTemplate
;
369 Count
= sizeof (mSataHcRegisterSaveTemplate
) / sizeof (OPAL_HC_PCI_REGISTER_SAVE
);
371 for (Index
= 0; Index
< Count
; Index
++) {
372 Offset
= HcRegisterSaveListPtr
[Index
].Address
;
373 Width
= HcRegisterSaveListPtr
[Index
].Width
;
376 case S3BootScriptWidthUint8
:
377 Data
= (UINT32
)PciRead8 (PCI_LIB_ADDRESS(Bus
,Device
,Function
,Offset
));
379 case S3BootScriptWidthUint16
:
380 Data
= (UINT32
)PciRead16 (PCI_LIB_ADDRESS(Bus
,Device
,Function
,Offset
));
382 case S3BootScriptWidthUint32
:
383 Data
= PciRead32 (PCI_LIB_ADDRESS(Bus
,Device
,Function
,Offset
));
390 Address
= S3_BOOT_SCRIPT_LIB_PCI_ADDRESS (Bus
, Device
, Function
, Offset
);
391 Status
= S3BootScriptSavePciCfgWrite (Width
, Address
, 1, &Data
);
392 ASSERT_EFI_ERROR (Status
);
397 Build ATA OPAL device info and save them to LockBox.
399 @param[in] BarAddr Bar address allocated.
403 BuildOpalDeviceInfoAta (
409 OPAL_DEVICE_ATA
*DevInfoAta
;
410 OPAL_DEVICE_ATA
*TempDevInfoAta
;
411 UINTN DevInfoLengthAta
;
412 UINT16 DevInfoLength
;
413 OPAL_DRIVER_DEVICE
*TmpDev
;
416 // Build ATA OPAL device info and save them to LockBox.
418 DevInfoLengthAta
= 0;
419 TmpDev
= mOpalDriver
.DeviceList
;
420 while (TmpDev
!= NULL
) {
421 DeviceType
= ExtractDeviceInfoFromDevicePath (
422 TmpDev
->OpalDisk
.OpalDevicePath
,
426 if (DeviceType
== OPAL_DEVICE_TYPE_ATA
) {
427 DevInfoLengthAta
+= DevInfoLength
;
430 TmpDev
= TmpDev
->Next
;
433 if (DevInfoLengthAta
== 0) {
437 DevInfoAta
= AllocateZeroPool (DevInfoLengthAta
);
438 ASSERT (DevInfoAta
!= NULL
);
440 TempDevInfoAta
= DevInfoAta
;
441 TmpDev
= mOpalDriver
.DeviceList
;
442 while (TmpDev
!= NULL
) {
443 DeviceType
= ExtractDeviceInfoFromDevicePath (
444 TmpDev
->OpalDisk
.OpalDevicePath
,
448 if (DeviceType
== OPAL_DEVICE_TYPE_ATA
) {
449 ExtractDeviceInfoFromDevicePath (
450 TmpDev
->OpalDisk
.OpalDevicePath
,
452 (OPAL_DEVICE_COMMON
*) TempDevInfoAta
454 TempDevInfoAta
->Length
= DevInfoLength
;
455 TempDevInfoAta
->OpalBaseComId
= TmpDev
->OpalDisk
.OpalBaseComId
;
456 TempDevInfoAta
->BarAddr
= BarAddr
;
458 TempDevInfoAta
->Password
,
459 TmpDev
->OpalDisk
.Password
,
460 TmpDev
->OpalDisk
.PasswordLength
462 TempDevInfoAta
->PasswordLength
= TmpDev
->OpalDisk
.PasswordLength
;
463 OpalDeviceAtaSaveBootScript (TempDevInfoAta
);
464 TempDevInfoAta
= (OPAL_DEVICE_ATA
*) ((UINTN
) TempDevInfoAta
+ DevInfoLength
);
467 TmpDev
= TmpDev
->Next
;
470 Status
= SaveLockBox (
475 ASSERT_EFI_ERROR (Status
);
477 Status
= SetLockBoxAttributes (
479 LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY
481 ASSERT_EFI_ERROR (Status
);
483 ZeroMem (DevInfoAta
, DevInfoLengthAta
);
484 FreePool (DevInfoAta
);
488 Build NVMe OPAL device info and save them to LockBox.
490 @param[in] BarAddr Bar address allocated.
494 BuildOpalDeviceInfoNvme (
500 OPAL_DEVICE_NVME
*DevInfoNvme
;
501 OPAL_DEVICE_NVME
*TempDevInfoNvme
;
502 UINTN DevInfoLengthNvme
;
503 UINT16 DevInfoLength
;
504 OPAL_DRIVER_DEVICE
*TmpDev
;
507 // Build NVMe OPAL device info and save them to LockBox.
509 DevInfoLengthNvme
= 0;
510 TmpDev
= mOpalDriver
.DeviceList
;
511 while (TmpDev
!= NULL
) {
512 DeviceType
= ExtractDeviceInfoFromDevicePath (
513 TmpDev
->OpalDisk
.OpalDevicePath
,
517 if (DeviceType
== OPAL_DEVICE_TYPE_NVME
) {
518 DevInfoLengthNvme
+= DevInfoLength
;
521 TmpDev
= TmpDev
->Next
;
524 if (DevInfoLengthNvme
== 0) {
528 DevInfoNvme
= AllocateZeroPool (DevInfoLengthNvme
);
529 ASSERT (DevInfoNvme
!= NULL
);
531 TempDevInfoNvme
= DevInfoNvme
;
532 TmpDev
= mOpalDriver
.DeviceList
;
533 while (TmpDev
!= NULL
) {
534 DeviceType
= ExtractDeviceInfoFromDevicePath (
535 TmpDev
->OpalDisk
.OpalDevicePath
,
539 if (DeviceType
== OPAL_DEVICE_TYPE_NVME
) {
540 ExtractDeviceInfoFromDevicePath (
541 TmpDev
->OpalDisk
.OpalDevicePath
,
543 (OPAL_DEVICE_COMMON
*) TempDevInfoNvme
545 TempDevInfoNvme
->Length
= DevInfoLength
;
546 TempDevInfoNvme
->OpalBaseComId
= TmpDev
->OpalDisk
.OpalBaseComId
;
547 TempDevInfoNvme
->BarAddr
= BarAddr
;
549 TempDevInfoNvme
->Password
,
550 TmpDev
->OpalDisk
.Password
,
551 TmpDev
->OpalDisk
.PasswordLength
553 TempDevInfoNvme
->PasswordLength
= TmpDev
->OpalDisk
.PasswordLength
;
554 TempDevInfoNvme
= (OPAL_DEVICE_NVME
*) ((UINTN
) TempDevInfoNvme
+ DevInfoLength
);
557 TmpDev
= TmpDev
->Next
;
560 Status
= SaveLockBox (
561 &mOpalDeviceNvmeGuid
,
565 ASSERT_EFI_ERROR (Status
);
567 Status
= SetLockBoxAttributes (
568 &mOpalDeviceNvmeGuid
,
569 LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY
571 ASSERT_EFI_ERROR (Status
);
573 ZeroMem (DevInfoNvme
, DevInfoLengthNvme
);
574 FreePool (DevInfoNvme
);
578 Notification function of EFI_END_OF_DXE_EVENT_GROUP_GUID event group.
580 This is a notification function registered on EFI_END_OF_DXE_EVENT_GROUP_GUID event group.
582 @param Event Event whose notification function is being invoked.
583 @param Context Pointer to the notification function's context.
588 OpalEndOfDxeEventNotify (
594 EFI_PHYSICAL_ADDRESS Address
;
596 OPAL_DRIVER_DEVICE
*TmpDev
;
598 DEBUG ((DEBUG_INFO
, "%a() - enter\n", __FUNCTION__
));
600 mOpalEndOfDxe
= TRUE
;
602 if (mOpalRequestVariable
!= NULL
) {
604 // Free the OPAL request variable buffer here
605 // as the OPAL requests should have been processed.
607 FreePool (mOpalRequestVariable
);
608 mOpalRequestVariable
= NULL
;
609 mOpalRequestVariableSize
= 0;
613 // If no any device, return directly.
615 if (mOpalDriver
.DeviceList
== NULL
) {
616 gBS
->CloseEvent (Event
);
621 // Assume 64K size and alignment are enough.
624 Address
= 0xFFFFFFFF;
625 Status
= gDS
->AllocateMemorySpace (
626 EfiGcdAllocateMaxAddressSearchBottomUp
,
627 EfiGcdMemoryTypeMemoryMappedIo
,
628 16, // 2^16: 64K Alignment
634 ASSERT_EFI_ERROR (Status
);
636 BuildOpalDeviceInfoAta ((UINT32
) Address
);
637 BuildOpalDeviceInfoNvme ((UINT32
) Address
);
642 TmpDev
= mOpalDriver
.DeviceList
;
643 while (TmpDev
!= NULL
) {
644 ZeroMem (TmpDev
->OpalDisk
.Password
, TmpDev
->OpalDisk
.PasswordLength
);
645 TmpDev
= TmpDev
->Next
;
648 DEBUG ((DEBUG_INFO
, "%a() - exit\n", __FUNCTION__
));
650 gBS
->CloseEvent (Event
);
654 Get Psid input from the popup window.
656 @param[in] Dev The device which need Psid to process Psid Revert
658 @param[in] PopUpString Pop up string.
659 @param[in] PopUpString2 Pop up string in line 2.
661 @param[out] PressEsc Whether user escape function through Press ESC.
663 @retval Psid string if success. NULL if failed.
667 OpalDriverPopUpPsidInput (
668 IN OPAL_DRIVER_DEVICE
*Dev
,
669 IN CHAR16
*PopUpString
,
670 IN CHAR16
*PopUpString2
,
671 OUT BOOLEAN
*PressEsc
674 EFI_INPUT_KEY InputKey
;
676 CHAR16 Mask
[PSID_CHARACTER_LENGTH
+ 1];
677 CHAR16 Unicode
[PSID_CHARACTER_LENGTH
+ 1];
680 ZeroMem(Unicode
, sizeof(Unicode
));
681 ZeroMem(Mask
, sizeof(Mask
));
685 gST
->ConOut
->ClearScreen(gST
->ConOut
);
689 Mask
[InputLength
] = L
'_';
690 if (PopUpString2
== NULL
) {
692 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
695 L
"---------------------",
701 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
705 L
"---------------------",
714 if (InputKey
.ScanCode
== SCAN_NULL
) {
718 if (InputKey
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
720 // Add the null terminator.
722 Unicode
[InputLength
] = 0;
723 Mask
[InputLength
] = 0;
725 } else if ((InputKey
.UnicodeChar
== CHAR_NULL
) ||
726 (InputKey
.UnicodeChar
== CHAR_TAB
) ||
727 (InputKey
.UnicodeChar
== CHAR_LINEFEED
)
732 // delete last key entered
734 if (InputKey
.UnicodeChar
== CHAR_BACKSPACE
) {
735 if (InputLength
> 0) {
736 Unicode
[InputLength
] = 0;
737 Mask
[InputLength
] = 0;
742 // add Next key entry
744 Unicode
[InputLength
] = InputKey
.UnicodeChar
;
745 Mask
[InputLength
] = InputKey
.UnicodeChar
;
747 if (InputLength
== PSID_CHARACTER_LENGTH
) {
749 // Add the null terminator.
751 Unicode
[InputLength
] = 0;
752 Mask
[InputLength
] = 0;
762 if (InputKey
.ScanCode
== SCAN_ESC
) {
768 gST
->ConOut
->ClearScreen(gST
->ConOut
);
770 if (InputLength
== 0 || InputKey
.ScanCode
== SCAN_ESC
) {
771 ZeroMem (Unicode
, sizeof (Unicode
));
772 ZeroMem (Mask
, sizeof (Mask
));
776 Ascii
= AllocateZeroPool (PSID_CHARACTER_LENGTH
+ 1);
778 ZeroMem (Unicode
, sizeof (Unicode
));
779 ZeroMem (Mask
, sizeof (Mask
));
783 UnicodeStrToAsciiStrS (Unicode
, Ascii
, PSID_CHARACTER_LENGTH
+ 1);
784 ZeroMem (Unicode
, sizeof (Unicode
));
785 ZeroMem (Mask
, sizeof (Mask
));
792 Get password input from the popup window.
794 @param[in] Dev The device which need password to unlock or
795 process OPAL request.
796 @param[in] PopUpString1 Pop up string 1.
797 @param[in] PopUpString2 Pop up string 2.
798 @param[out] PressEsc Whether user escape function through Press ESC.
800 @retval Password string if success. NULL if failed.
804 OpalDriverPopUpPasswordInput (
805 IN OPAL_DRIVER_DEVICE
*Dev
,
806 IN CHAR16
*PopUpString1
,
807 IN CHAR16
*PopUpString2
,
808 OUT BOOLEAN
*PressEsc
811 EFI_INPUT_KEY InputKey
;
813 CHAR16 Mask
[OPAL_MAX_PASSWORD_SIZE
+ 1];
814 CHAR16 Unicode
[OPAL_MAX_PASSWORD_SIZE
+ 1];
817 ZeroMem(Unicode
, sizeof(Unicode
));
818 ZeroMem(Mask
, sizeof(Mask
));
822 gST
->ConOut
->ClearScreen(gST
->ConOut
);
826 Mask
[InputLength
] = L
'_';
827 if (PopUpString2
== NULL
) {
829 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
832 L
"---------------------",
838 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
842 L
"---------------------",
851 if (InputKey
.ScanCode
== SCAN_NULL
) {
855 if (InputKey
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
857 // Add the null terminator.
859 Unicode
[InputLength
] = 0;
860 Mask
[InputLength
] = 0;
862 } else if ((InputKey
.UnicodeChar
== CHAR_NULL
) ||
863 (InputKey
.UnicodeChar
== CHAR_TAB
) ||
864 (InputKey
.UnicodeChar
== CHAR_LINEFEED
)
869 // delete last key entered
871 if (InputKey
.UnicodeChar
== CHAR_BACKSPACE
) {
872 if (InputLength
> 0) {
873 Unicode
[InputLength
] = 0;
874 Mask
[InputLength
] = 0;
879 // add Next key entry
881 Unicode
[InputLength
] = InputKey
.UnicodeChar
;
882 Mask
[InputLength
] = L
'*';
884 if (InputLength
== OPAL_MAX_PASSWORD_SIZE
) {
886 // Add the null terminator.
888 Unicode
[InputLength
] = 0;
889 Mask
[InputLength
] = 0;
899 if (InputKey
.ScanCode
== SCAN_ESC
) {
905 gST
->ConOut
->ClearScreen(gST
->ConOut
);
907 if (InputLength
== 0 || InputKey
.ScanCode
== SCAN_ESC
) {
908 ZeroMem (Unicode
, sizeof (Unicode
));
912 Ascii
= AllocateZeroPool (OPAL_MAX_PASSWORD_SIZE
+ 1);
914 ZeroMem (Unicode
, sizeof (Unicode
));
918 UnicodeStrToAsciiStrS (Unicode
, Ascii
, OPAL_MAX_PASSWORD_SIZE
+ 1);
919 ZeroMem (Unicode
, sizeof (Unicode
));
927 @param[in] Dev The OPAL device.
928 @param[in] RequestString Request string.
930 @return Pop up string.
935 IN OPAL_DRIVER_DEVICE
*Dev
,
936 IN CHAR16
*RequestString
939 if (Dev
->Name16
== NULL
) {
940 UnicodeSPrint (mPopUpString
, sizeof (mPopUpString
), L
"%s Disk", RequestString
);
942 UnicodeSPrint (mPopUpString
, sizeof (mPopUpString
), L
"%s %s", RequestString
, Dev
->Name16
);
949 Check if disk is locked, show popup window and ask for password if it is.
951 @param[in] Dev The device which need to be unlocked.
952 @param[in] RequestString Request string.
956 OpalDriverRequestPassword (
957 IN OPAL_DRIVER_DEVICE
*Dev
,
958 IN CHAR16
*RequestString
966 OPAL_SESSION Session
;
976 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
978 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
982 IsEnabled
= OpalFeatureEnabled (&Dev
->OpalDisk
.SupportedAttributes
, &Dev
->OpalDisk
.LockingFeature
);
984 ZeroMem(&Session
, sizeof(Session
));
985 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
986 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
987 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
989 IsLocked
= OpalDeviceLocked (&Dev
->OpalDisk
.SupportedAttributes
, &Dev
->OpalDisk
.LockingFeature
);
991 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
992 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, NULL
, &PressEsc
);
996 // Current device in the lock status and
997 // User not input password and press ESC,
998 // keep device in lock status and continue boot.
1002 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1004 L
"Press ENTER to skip the request and continue boot,",
1005 L
"Press ESC to input password again",
1008 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1010 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1011 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1013 // Keep lock and continue boot.
1018 // Let user input password again.
1024 // Current device in the unlock status and
1025 // User not input password and press ESC,
1026 // Shutdown the device.
1030 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1032 L
"Press ENTER to shutdown, Press ESC to input password again",
1035 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1037 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1038 gRT
->ResetSystem (EfiResetShutdown
, EFI_SUCCESS
, 0, NULL
);
1041 // Let user input password again.
1048 if (Password
== NULL
) {
1052 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1055 Ret
= OpalUtilUpdateGlobalLockingRange(&Session
, Password
, PasswordLen
, FALSE
, FALSE
);
1057 Ret
= OpalUtilUpdateGlobalLockingRange(&Session
, Password
, PasswordLen
, TRUE
, TRUE
);
1058 if (Ret
== TcgResultSuccess
) {
1059 Ret
= OpalUtilUpdateGlobalLockingRange(&Session
, Password
, PasswordLen
, FALSE
, FALSE
);
1063 if (Ret
== TcgResultSuccess
) {
1064 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1065 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1067 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1070 if (Password
!= NULL
) {
1071 ZeroMem (Password
, PasswordLen
);
1072 FreePool (Password
);
1075 if (Ret
== TcgResultSuccess
) {
1080 // Check whether opal device's Tries value has reach the TryLimit value, if yes, force a shutdown
1081 // before accept new password.
1083 if (Ret
== TcgResultFailureInvalidType
) {
1084 Count
= MAX_PASSWORD_TRY_COUNT
;
1092 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1094 L
"Invalid password.",
1095 L
"Press ENTER to retry",
1098 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1101 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1104 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1106 L
"Opal password retry count exceeds the limit. Must shutdown!",
1107 L
"Press ENTER to shutdown",
1110 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1112 gRT
->ResetSystem (EfiResetShutdown
, EFI_SUCCESS
, 0, NULL
);
1118 Process Enable Feature OPAL request.
1120 @param[in] Dev The device which has Enable Feature OPAL request.
1121 @param[in] RequestString Request string.
1125 ProcessOpalRequestEnableFeature (
1126 IN OPAL_DRIVER_DEVICE
*Dev
,
1127 IN CHAR16
*RequestString
1133 CHAR8
*PasswordConfirm
;
1134 UINT32 PasswordLenConfirm
;
1135 OPAL_SESSION Session
;
1139 CHAR16
*PopUpString
;
1145 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1147 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1151 ZeroMem(&Session
, sizeof(Session
));
1152 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1153 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1154 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1156 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
1157 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please type in your new password", &PressEsc
);
1161 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1163 L
"Press ENTER to skip the request and continue boot,",
1164 L
"Press ESC to input password again",
1167 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1169 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1170 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1174 // Let user input password again.
1180 if (Password
== NULL
) {
1184 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1186 PasswordConfirm
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please confirm your new password", &PressEsc
);
1187 if (PasswordConfirm
== NULL
) {
1188 ZeroMem (Password
, PasswordLen
);
1189 FreePool (Password
);
1193 PasswordLenConfirm
= (UINT32
) AsciiStrLen(PasswordConfirm
);
1194 if ((PasswordLen
!= PasswordLenConfirm
) ||
1195 (CompareMem (Password
, PasswordConfirm
, PasswordLen
) != 0)) {
1196 ZeroMem (Password
, PasswordLen
);
1197 FreePool (Password
);
1198 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
1199 FreePool (PasswordConfirm
);
1202 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1204 L
"Passwords are not the same.",
1205 L
"Press ENTER to retry",
1208 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1213 if (PasswordConfirm
!= NULL
) {
1214 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
1215 FreePool (PasswordConfirm
);
1218 Ret
= OpalSupportEnableOpalFeature (&Session
, Dev
->OpalDisk
.Msid
, Dev
->OpalDisk
.MsidLength
, Password
, PasswordLen
);
1219 if (Ret
== TcgResultSuccess
) {
1220 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1221 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1223 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1226 if (Password
!= NULL
) {
1227 ZeroMem (Password
, PasswordLen
);
1228 FreePool (Password
);
1231 if (Ret
== TcgResultSuccess
) {
1239 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1242 L
"Press ENTER to retry",
1245 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1248 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1251 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1253 L
"Opal password retry count exceeds the limit.",
1254 L
"Press ENTER to skip the request and continue boot",
1257 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1258 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1263 Process Disable User OPAL request.
1265 @param[in] Dev The device which has Disable User OPAL request.
1266 @param[in] RequestString Request string.
1270 ProcessOpalRequestDisableUser (
1271 IN OPAL_DRIVER_DEVICE
*Dev
,
1272 IN CHAR16
*RequestString
1278 OPAL_SESSION Session
;
1282 BOOLEAN PasswordFailed
;
1283 CHAR16
*PopUpString
;
1289 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1291 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1295 ZeroMem(&Session
, sizeof(Session
));
1296 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1297 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1298 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1300 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
1301 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, NULL
, &PressEsc
);
1305 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1307 L
"Press ENTER to skip the request and continue boot,",
1308 L
"Press ESC to input password again",
1311 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1313 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1314 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1318 // Let user input password again.
1324 if (Password
== NULL
) {
1328 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1330 Ret
= OpalUtilDisableUser(&Session
, Password
, PasswordLen
, &PasswordFailed
);
1331 if (Ret
== TcgResultSuccess
) {
1332 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1333 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1335 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1338 if (Password
!= NULL
) {
1339 ZeroMem (Password
, PasswordLen
);
1340 FreePool (Password
);
1343 if (Ret
== TcgResultSuccess
) {
1351 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1353 L
"Invalid password, request failed.",
1354 L
"Press ENTER to retry",
1357 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1360 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1363 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1365 L
"Opal password retry count exceeds the limit.",
1366 L
"Press ENTER to skip the request and continue boot",
1369 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1370 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1375 Process Psid Revert OPAL request.
1377 @param[in] Dev The device which has Psid Revert OPAL request.
1378 @param[in] RequestString Request string.
1382 ProcessOpalRequestPsidRevert (
1383 IN OPAL_DRIVER_DEVICE
*Dev
,
1384 IN CHAR16
*RequestString
1390 OPAL_SESSION Session
;
1394 CHAR16
*PopUpString
;
1395 CHAR16
*PopUpString2
;
1402 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1404 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1406 if (Dev
->OpalDisk
.EstimateTimeCost
> MAX_ACCEPTABLE_REVERTING_TIME
) {
1407 BufferSize
= StrSize (L
"Warning: Revert action will take about ####### seconds, DO NOT power off system during the revert action!");
1408 PopUpString2
= AllocateZeroPool (BufferSize
);
1409 ASSERT (PopUpString2
!= NULL
);
1413 L
"WARNING: Revert action will take about %d seconds, DO NOT power off system during the revert action!",
1414 Dev
->OpalDisk
.EstimateTimeCost
1417 PopUpString2
= NULL
;
1422 ZeroMem(&Session
, sizeof(Session
));
1423 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1424 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1425 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1427 while (Count
< MAX_PSID_TRY_COUNT
) {
1428 Psid
= OpalDriverPopUpPsidInput (Dev
, PopUpString
, PopUpString2
, &PressEsc
);
1432 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1434 L
"Press ENTER to skip the request and continue boot,",
1435 L
"Press ESC to input Psid again",
1438 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1440 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1441 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1445 // Let user input Psid again.
1455 PsidLen
= (UINT32
) AsciiStrLen(Psid
);
1457 Ret
= OpalUtilPsidRevert(&Session
, Psid
, PsidLen
);
1458 if (Ret
== TcgResultSuccess
) {
1459 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1461 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1465 ZeroMem (Psid
, PsidLen
);
1469 if (Ret
== TcgResultSuccess
) {
1477 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1479 L
"Invalid Psid, request failed.",
1480 L
"Press ENTER to retry",
1483 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1486 if (Count
>= MAX_PSID_TRY_COUNT
) {
1489 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1491 L
"Opal Psid retry count exceeds the limit.",
1492 L
"Press ENTER to skip the request and continue boot",
1495 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1496 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1500 if (PopUpString2
!= NULL
) {
1501 FreePool (PopUpString2
);
1506 Process Admin Revert OPAL request.
1508 @param[in] Dev The device which has Revert OPAL request.
1509 @param[in] KeepUserData Whether to keep user data or not.
1510 @param[in] RequestString Request string.
1514 ProcessOpalRequestRevert (
1515 IN OPAL_DRIVER_DEVICE
*Dev
,
1516 IN BOOLEAN KeepUserData
,
1517 IN CHAR16
*RequestString
1523 OPAL_SESSION Session
;
1527 BOOLEAN PasswordFailed
;
1528 CHAR16
*PopUpString
;
1529 CHAR16
*PopUpString2
;
1536 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1538 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1540 if (Dev
->OpalDisk
.EstimateTimeCost
> MAX_ACCEPTABLE_REVERTING_TIME
) {
1541 BufferSize
= StrSize (L
"Warning: Revert action will take about ####### seconds, DO NOT power off system during the revert action!");
1542 PopUpString2
= AllocateZeroPool (BufferSize
);
1543 ASSERT (PopUpString2
!= NULL
);
1547 L
"WARNING: Revert action will take about %d seconds, DO NOT power off system during the revert action!",
1548 Dev
->OpalDisk
.EstimateTimeCost
1551 PopUpString2
= NULL
;
1556 ZeroMem(&Session
, sizeof(Session
));
1557 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1558 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1559 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1561 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
1562 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, PopUpString2
, &PressEsc
);
1566 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1568 L
"Press ENTER to skip the request and continue boot,",
1569 L
"Press ESC to input password again",
1572 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1574 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1575 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1579 // Let user input password again.
1585 if (Password
== NULL
) {
1589 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1591 if ((Dev
->OpalDisk
.SupportedAttributes
.PyriteSsc
== 1) &&
1592 (Dev
->OpalDisk
.LockingFeature
.MediaEncryption
== 0)) {
1594 // For pyrite type device which does not support media encryption,
1595 // it does not accept "Keep User Data" parameter.
1596 // So here hardcode a FALSE for this case.
1598 Ret
= OpalUtilRevert(
1605 Dev
->OpalDisk
.MsidLength
1608 Ret
= OpalUtilRevert(
1615 Dev
->OpalDisk
.MsidLength
1618 if (Ret
== TcgResultSuccess
) {
1619 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1620 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1622 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1625 if (Password
!= NULL
) {
1626 ZeroMem (Password
, PasswordLen
);
1627 FreePool (Password
);
1630 if (Ret
== TcgResultSuccess
) {
1638 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1640 L
"Invalid password, request failed.",
1641 L
"Press ENTER to retry",
1644 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1647 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1650 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1652 L
"Opal password retry count exceeds the limit.",
1653 L
"Press ENTER to skip the request and continue boot",
1656 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1657 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1661 if (PopUpString2
!= NULL
) {
1662 FreePool (PopUpString2
);
1667 Process Secure Erase OPAL request.
1669 @param[in] Dev The device which has Secure Erase OPAL request.
1670 @param[in] RequestString Request string.
1674 ProcessOpalRequestSecureErase (
1675 IN OPAL_DRIVER_DEVICE
*Dev
,
1676 IN CHAR16
*RequestString
1682 OPAL_SESSION Session
;
1686 BOOLEAN PasswordFailed
;
1687 CHAR16
*PopUpString
;
1693 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1695 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1699 ZeroMem(&Session
, sizeof(Session
));
1700 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1701 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1702 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1704 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
1705 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, NULL
, &PressEsc
);
1709 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1711 L
"Press ENTER to skip the request and continue boot,",
1712 L
"Press ESC to input password again",
1715 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1717 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1718 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1722 // Let user input password again.
1728 if (Password
== NULL
) {
1732 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1734 Ret
= OpalUtilSecureErase(&Session
, Password
, PasswordLen
, &PasswordFailed
);
1735 if (Ret
== TcgResultSuccess
) {
1736 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1737 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1739 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1742 if (Password
!= NULL
) {
1743 ZeroMem (Password
, PasswordLen
);
1744 FreePool (Password
);
1747 if (Ret
== TcgResultSuccess
) {
1755 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1757 L
"Invalid password, request failed.",
1758 L
"Press ENTER to retry",
1761 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1764 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1767 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1769 L
"Opal password retry count exceeds the limit.",
1770 L
"Press ENTER to skip the request and continue boot",
1773 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1774 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1779 Process Set Admin Pwd OPAL request.
1781 @param[in] Dev The device which has Set Admin Pwd Feature OPAL request.
1782 @param[in] RequestString Request string.
1786 ProcessOpalRequestSetUserPwd (
1787 IN OPAL_DRIVER_DEVICE
*Dev
,
1788 IN CHAR16
*RequestString
1793 UINT32 OldPasswordLen
;
1796 CHAR8
*PasswordConfirm
;
1797 UINT32 PasswordLenConfirm
;
1798 OPAL_SESSION Session
;
1802 CHAR16
*PopUpString
;
1808 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
1810 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
1814 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
1815 OldPassword
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please type in your password", &PressEsc
);
1819 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1821 L
"Press ENTER to skip the request and continue boot,",
1822 L
"Press ESC to input password again",
1825 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
1827 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
1828 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1832 // Let user input password again.
1838 if (OldPassword
== NULL
) {
1842 OldPasswordLen
= (UINT32
) AsciiStrLen(OldPassword
);
1844 ZeroMem(&Session
, sizeof(Session
));
1845 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1846 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1847 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1848 Ret
= OpalUtilVerifyPassword (&Session
, OldPassword
, OldPasswordLen
, OPAL_LOCKING_SP_USER1_AUTHORITY
);
1849 if (Ret
== TcgResultSuccess
) {
1850 DEBUG ((DEBUG_INFO
, "Verify with USER1 authority : Success\n"));
1852 Ret
= OpalUtilVerifyPassword (&Session
, OldPassword
, OldPasswordLen
, OPAL_LOCKING_SP_ADMIN1_AUTHORITY
);
1853 if (Ret
== TcgResultSuccess
) {
1854 DEBUG ((DEBUG_INFO
, "Verify with ADMIN1 authority: Success\n"));
1856 ZeroMem (OldPassword
, OldPasswordLen
);
1857 FreePool (OldPassword
);
1858 DEBUG ((DEBUG_INFO
, "Verify: Failure\n"));
1861 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1863 L
"Incorrect password.",
1864 L
"Press ENTER to retry",
1867 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1873 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please type in your new password", &PressEsc
);
1874 if (Password
== NULL
) {
1875 ZeroMem (OldPassword
, OldPasswordLen
);
1876 FreePool (OldPassword
);
1880 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
1882 PasswordConfirm
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please confirm your new password", &PressEsc
);
1883 if (PasswordConfirm
== NULL
) {
1884 ZeroMem (OldPassword
, OldPasswordLen
);
1885 FreePool (OldPassword
);
1886 ZeroMem (Password
, PasswordLen
);
1887 FreePool (Password
);
1891 PasswordLenConfirm
= (UINT32
) AsciiStrLen(PasswordConfirm
);
1892 if ((PasswordLen
!= PasswordLenConfirm
) ||
1893 (CompareMem (Password
, PasswordConfirm
, PasswordLen
) != 0)) {
1894 ZeroMem (OldPassword
, OldPasswordLen
);
1895 FreePool (OldPassword
);
1896 ZeroMem (Password
, PasswordLen
);
1897 FreePool (Password
);
1898 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
1899 FreePool (PasswordConfirm
);
1902 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1904 L
"Passwords are not the same.",
1905 L
"Press ENTER to retry",
1908 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1913 if (PasswordConfirm
!= NULL
) {
1914 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
1915 FreePool (PasswordConfirm
);
1918 ZeroMem(&Session
, sizeof(Session
));
1919 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
1920 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
1921 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
1922 Ret
= OpalUtilSetUserPassword(
1929 if (Ret
== TcgResultSuccess
) {
1930 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
1931 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
1933 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
1936 if (OldPassword
!= NULL
) {
1937 ZeroMem (OldPassword
, OldPasswordLen
);
1938 FreePool (OldPassword
);
1941 if (Password
!= NULL
) {
1942 ZeroMem (Password
, PasswordLen
);
1943 FreePool (Password
);
1946 if (Ret
== TcgResultSuccess
) {
1954 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1957 L
"Press ENTER to retry",
1960 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1963 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
1966 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
1968 L
"Opal password retry count exceeds the limit.",
1969 L
"Press ENTER to skip the request and continue boot",
1972 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
1973 gST
->ConOut
->ClearScreen(gST
->ConOut
);
1978 Process Set Admin Pwd OPAL request.
1980 @param[in] Dev The device which has Set Admin Pwd Feature OPAL request.
1981 @param[in] RequestString Request string.
1985 ProcessOpalRequestSetAdminPwd (
1986 IN OPAL_DRIVER_DEVICE
*Dev
,
1987 IN CHAR16
*RequestString
1992 UINT32 OldPasswordLen
;
1995 CHAR8
*PasswordConfirm
;
1996 UINT32 PasswordLenConfirm
;
1997 OPAL_SESSION Session
;
2001 CHAR16
*PopUpString
;
2007 DEBUG ((DEBUG_INFO
, "%a()\n", __FUNCTION__
));
2009 PopUpString
= OpalGetPopUpString (Dev
, RequestString
);
2013 while (Count
< MAX_PASSWORD_TRY_COUNT
) {
2014 OldPassword
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please type in your password", &PressEsc
);
2018 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
2020 L
"Press ENTER to skip the request and continue boot,",
2021 L
"Press ESC to input password again",
2024 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
2026 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
2027 gST
->ConOut
->ClearScreen(gST
->ConOut
);
2031 // Let user input password again.
2037 if (OldPassword
== NULL
) {
2041 OldPasswordLen
= (UINT32
) AsciiStrLen(OldPassword
);
2043 ZeroMem(&Session
, sizeof(Session
));
2044 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
2045 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
2046 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
2047 Ret
= OpalUtilVerifyPassword (&Session
, OldPassword
, OldPasswordLen
, OPAL_LOCKING_SP_ADMIN1_AUTHORITY
);
2048 if (Ret
== TcgResultSuccess
) {
2049 DEBUG ((DEBUG_INFO
, "Verify: Success\n"));
2051 ZeroMem (OldPassword
, OldPasswordLen
);
2052 FreePool (OldPassword
);
2053 DEBUG ((DEBUG_INFO
, "Verify: Failure\n"));
2056 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
2058 L
"Incorrect password.",
2059 L
"Press ENTER to retry",
2062 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
2067 Password
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please type in your new password", &PressEsc
);
2068 if (Password
== NULL
) {
2069 ZeroMem (OldPassword
, OldPasswordLen
);
2070 FreePool (OldPassword
);
2074 PasswordLen
= (UINT32
) AsciiStrLen(Password
);
2076 PasswordConfirm
= OpalDriverPopUpPasswordInput (Dev
, PopUpString
, L
"Please confirm your new password", &PressEsc
);
2077 if (PasswordConfirm
== NULL
) {
2078 ZeroMem (OldPassword
, OldPasswordLen
);
2079 FreePool (OldPassword
);
2080 ZeroMem (Password
, PasswordLen
);
2081 FreePool (Password
);
2085 PasswordLenConfirm
= (UINT32
) AsciiStrLen(PasswordConfirm
);
2086 if ((PasswordLen
!= PasswordLenConfirm
) ||
2087 (CompareMem (Password
, PasswordConfirm
, PasswordLen
) != 0)) {
2088 ZeroMem (OldPassword
, OldPasswordLen
);
2089 FreePool (OldPassword
);
2090 ZeroMem (Password
, PasswordLen
);
2091 FreePool (Password
);
2092 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
2093 FreePool (PasswordConfirm
);
2096 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
2098 L
"Passwords are not the same.",
2099 L
"Press ENTER to retry",
2102 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
2107 if (PasswordConfirm
!= NULL
) {
2108 ZeroMem (PasswordConfirm
, PasswordLenConfirm
);
2109 FreePool (PasswordConfirm
);
2113 ZeroMem(&Session
, sizeof(Session
));
2114 Session
.Sscp
= Dev
->OpalDisk
.Sscp
;
2115 Session
.MediaId
= Dev
->OpalDisk
.MediaId
;
2116 Session
.OpalBaseComId
= Dev
->OpalDisk
.OpalBaseComId
;
2117 Ret
= OpalUtilSetAdminPassword(
2124 if (Ret
== TcgResultSuccess
) {
2125 OpalSupportUpdatePassword (&Dev
->OpalDisk
, Password
, PasswordLen
);
2126 DEBUG ((DEBUG_INFO
, "%s Success\n", RequestString
));
2128 DEBUG ((DEBUG_INFO
, "%s Failure\n", RequestString
));
2131 if (OldPassword
!= NULL
) {
2132 ZeroMem (OldPassword
, OldPasswordLen
);
2133 FreePool (OldPassword
);
2136 if (Password
!= NULL
) {
2137 ZeroMem (Password
, PasswordLen
);
2138 FreePool (Password
);
2141 if (Ret
== TcgResultSuccess
) {
2149 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
2152 L
"Press ENTER to retry",
2155 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
2158 if (Count
>= MAX_PASSWORD_TRY_COUNT
) {
2161 EFI_LIGHTGRAY
| EFI_BACKGROUND_BLUE
,
2163 L
"Opal password retry count exceeds the limit.",
2164 L
"Press ENTER to skip the request and continue boot",
2167 } while (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
);
2168 gST
->ConOut
->ClearScreen(gST
->ConOut
);
2173 Process OPAL request.
2175 @param[in] Dev The device which has OPAL request.
2179 ProcessOpalRequest (
2180 IN OPAL_DRIVER_DEVICE
*Dev
2184 OPAL_REQUEST_VARIABLE
*TempVariable
;
2185 OPAL_REQUEST_VARIABLE
*Variable
;
2187 EFI_DEVICE_PATH_PROTOCOL
*DevicePathInVariable
;
2188 UINTN DevicePathSizeInVariable
;
2189 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2190 UINTN DevicePathSize
;
2191 BOOLEAN KeepUserData
;
2193 DEBUG ((DEBUG_INFO
, "%a() - enter\n", __FUNCTION__
));
2195 if (mOpalRequestVariable
== NULL
) {
2196 Status
= GetVariable2 (
2197 OPAL_REQUEST_VARIABLE_NAME
,
2198 &gHiiSetupVariableGuid
,
2199 (VOID
**) &Variable
,
2202 if (EFI_ERROR (Status
) || (Variable
== NULL
)) {
2205 mOpalRequestVariable
= Variable
;
2206 mOpalRequestVariableSize
= VariableSize
;
2209 // Delete the OPAL request variable.
2211 Status
= gRT
->SetVariable (
2212 OPAL_REQUEST_VARIABLE_NAME
,
2213 (EFI_GUID
*) &gHiiSetupVariableGuid
,
2218 ASSERT_EFI_ERROR (Status
);
2220 Variable
= mOpalRequestVariable
;
2221 VariableSize
= mOpalRequestVariableSize
;
2225 // Process the OPAL requests.
2227 TempVariable
= Variable
;
2228 while ((VariableSize
> sizeof (OPAL_REQUEST_VARIABLE
)) &&
2229 (VariableSize
>= TempVariable
->Length
) &&
2230 (TempVariable
->Length
> sizeof (OPAL_REQUEST_VARIABLE
))) {
2231 DevicePathInVariable
= (EFI_DEVICE_PATH_PROTOCOL
*) ((UINTN
) TempVariable
+ sizeof (OPAL_REQUEST_VARIABLE
));
2232 DevicePathSizeInVariable
= GetDevicePathSize (DevicePathInVariable
);
2233 DevicePath
= Dev
->OpalDisk
.OpalDevicePath
;
2234 DevicePathSize
= GetDevicePathSize (DevicePath
);
2235 if ((DevicePathSize
== DevicePathSizeInVariable
) &&
2236 (CompareMem (DevicePath
, DevicePathInVariable
, DevicePathSize
) == 0)) {
2238 // Found the node for the OPAL device.
2240 if (TempVariable
->OpalRequest
.SetAdminPwd
!= 0) {
2241 ProcessOpalRequestSetAdminPwd (Dev
, L
"Update Admin Pwd:");
2243 if (TempVariable
->OpalRequest
.SetUserPwd
!= 0) {
2244 ProcessOpalRequestSetUserPwd (Dev
, L
"Set User Pwd:");
2246 if (TempVariable
->OpalRequest
.SecureErase
!= 0) {
2247 ProcessOpalRequestSecureErase (Dev
, L
"Secure Erase:");
2249 if (TempVariable
->OpalRequest
.Revert
!= 0) {
2250 KeepUserData
= (BOOLEAN
) TempVariable
->OpalRequest
.KeepUserData
;
2251 ProcessOpalRequestRevert (
2254 KeepUserData
? L
"Admin Revert(keep):" : L
"Admin Revert:"
2257 if (TempVariable
->OpalRequest
.PsidRevert
!= 0) {
2258 ProcessOpalRequestPsidRevert (Dev
, L
"Psid Revert:");
2260 if (TempVariable
->OpalRequest
.DisableUser
!= 0) {
2261 ProcessOpalRequestDisableUser (Dev
, L
"Disable User:");
2263 if (TempVariable
->OpalRequest
.EnableFeature
!= 0) {
2264 ProcessOpalRequestEnableFeature (Dev
, L
"Enable Feature:");
2270 VariableSize
-= TempVariable
->Length
;
2271 TempVariable
= (OPAL_REQUEST_VARIABLE
*) ((UINTN
) TempVariable
+ TempVariable
->Length
);
2274 DEBUG ((DEBUG_INFO
, "%a() - exit\n", __FUNCTION__
));
2278 Add new device to the global device list.
2280 @param Dev New create device.
2285 IN OPAL_DRIVER_DEVICE
*Dev
2288 OPAL_DRIVER_DEVICE
*TmpDev
;
2290 if (mOpalDriver
.DeviceList
== NULL
) {
2291 mOpalDriver
.DeviceList
= Dev
;
2293 TmpDev
= mOpalDriver
.DeviceList
;
2294 while (TmpDev
->Next
!= NULL
) {
2295 TmpDev
= TmpDev
->Next
;
2303 Remove one device in the global device list.
2305 @param Dev The device need to be removed.
2310 IN OPAL_DRIVER_DEVICE
*Dev
2313 OPAL_DRIVER_DEVICE
*TmpDev
;
2315 if (mOpalDriver
.DeviceList
== NULL
) {
2319 if (mOpalDriver
.DeviceList
== Dev
) {
2320 mOpalDriver
.DeviceList
= NULL
;
2324 TmpDev
= mOpalDriver
.DeviceList
;
2325 while (TmpDev
->Next
!= NULL
) {
2326 if (TmpDev
->Next
== Dev
) {
2327 TmpDev
->Next
= Dev
->Next
;
2334 Get current device count.
2336 @retval return the current created device count.
2345 OPAL_DRIVER_DEVICE
*TmpDev
;
2348 TmpDev
= mOpalDriver
.DeviceList
;
2350 while (TmpDev
!= NULL
) {
2352 TmpDev
= TmpDev
->Next
;
2359 Get devcie list info.
2361 @retval return the device list pointer.
2364 OpalDriverGetDeviceList(
2368 return mOpalDriver
.DeviceList
;
2372 ReadyToBoot callback to send BlockSid command.
2374 @param Event Pointer to this event
2375 @param Context Event handler private Data
2380 ReadyToBootCallback (
2385 OPAL_DRIVER_DEVICE
*Itr
;
2387 OPAL_SESSION Session
;
2388 UINT32 PpStorageFlag
;
2390 gBS
->CloseEvent (Event
);
2392 PpStorageFlag
= Tcg2PhysicalPresenceLibGetManagementFlags ();
2393 if ((PpStorageFlag
& TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID
) != 0) {
2395 // Send BlockSID command to each Opal disk
2397 Itr
= mOpalDriver
.DeviceList
;
2398 while (Itr
!= NULL
) {
2399 if (Itr
->OpalDisk
.SupportedAttributes
.BlockSid
) {
2400 ZeroMem(&Session
, sizeof(Session
));
2401 Session
.Sscp
= Itr
->OpalDisk
.Sscp
;
2402 Session
.MediaId
= Itr
->OpalDisk
.MediaId
;
2403 Session
.OpalBaseComId
= Itr
->OpalDisk
.OpalBaseComId
;
2405 DEBUG ((DEBUG_INFO
, "OpalPassword: ReadyToBoot point, send BlockSid command to device!\n"));
2406 Result
= OpalBlockSid (&Session
, TRUE
); // HardwareReset must always be TRUE
2407 if (Result
!= TcgResultSuccess
) {
2408 DEBUG ((DEBUG_ERROR
, "OpalBlockSid fail\n"));
2419 Stop this Controller.
2421 @param Dev The device need to be stopped.
2425 OpalDriverStopDevice (
2426 OPAL_DRIVER_DEVICE
*Dev
2432 FreePool(Dev
->Name16
);
2435 // remove OPAL_DRIVER_DEVICE from the list
2436 // it updates the controllerList pointer
2441 // close protocols that were opened
2445 &gEfiStorageSecurityCommandProtocolGuid
,
2446 gOpalDriverBinding
.DriverBindingHandle
,
2452 &gEfiBlockIoProtocolGuid
,
2453 gOpalDriverBinding
.DriverBindingHandle
,
2461 Get devcie name through the component name protocol.
2463 @param[in] AllHandlesBuffer The handle buffer for current system.
2464 @param[in] NumAllHandles The number of handles for the handle buffer.
2465 @param[in] Dev The device which need to get name.
2466 @param[in] UseComp1 Whether use component name or name2 protocol.
2468 @retval TRUE Find the name for this device.
2469 @retval FALSE Not found the name for this device.
2472 OpalDriverGetDeviceNameByProtocol(
2473 EFI_HANDLE
*AllHandlesBuffer
,
2474 UINTN NumAllHandles
,
2475 OPAL_DRIVER_DEVICE
*Dev
,
2479 EFI_HANDLE
* ProtocolHandlesBuffer
;
2480 UINTN NumProtocolHandles
;
2482 EFI_COMPONENT_NAME2_PROTOCOL
* Cnp1_2
; // efi component name and componentName2 have same layout
2485 EFI_DEVICE_PATH_PROTOCOL
* TmpDevPath
;
2488 EFI_HANDLE TmpHandle
;
2491 if (Dev
== NULL
|| AllHandlesBuffer
== NULL
|| NumAllHandles
== 0) {
2495 Protocol
= UseComp1
? gEfiComponentNameProtocolGuid
: gEfiComponentName2ProtocolGuid
;
2498 // Find all EFI_HANDLES with protocol
2500 Status
= gBS
->LocateHandleBuffer(
2504 &NumProtocolHandles
,
2505 &ProtocolHandlesBuffer
2507 if (EFI_ERROR(Status
)) {
2513 // Exit early if no supported devices
2515 if (NumProtocolHandles
== 0) {
2520 // Get printable name by iterating through all protocols
2521 // using the handle as the child, and iterate through all handles for the controller
2522 // exit loop early once found, if not found, then delete device
2523 // storage security protocol instances already exist, add them to internal list
2525 Status
= EFI_DEVICE_ERROR
;
2526 for (Index1
= 0; Index1
< NumProtocolHandles
; Index1
++) {
2529 if (Dev
->Name16
!= NULL
) {
2533 TmpHandle
= ProtocolHandlesBuffer
[Index1
];
2535 Status
= gBS
->OpenProtocol(
2541 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2543 if (EFI_ERROR(Status
) || Cnp1_2
== NULL
) {
2548 // Use all handles array as controller handle
2550 for (Index2
= 0; Index2
< NumAllHandles
; Index2
++) {
2551 Status
= Cnp1_2
->GetControllerName(
2553 AllHandlesBuffer
[Index2
],
2555 LANGUAGE_ISO_639_2_ENGLISH
,
2558 if (EFI_ERROR(Status
)) {
2559 Status
= Cnp1_2
->GetControllerName(
2561 AllHandlesBuffer
[Index2
],
2563 LANGUAGE_RFC_3066_ENGLISH
,
2567 if (!EFI_ERROR(Status
) && DevName
!= NULL
) {
2568 StrLength
= StrLen(DevName
) + 1; // Add one for NULL terminator
2569 Dev
->Name16
= AllocateZeroPool(StrLength
* sizeof (CHAR16
));
2570 ASSERT (Dev
->Name16
!= NULL
);
2571 StrCpyS (Dev
->Name16
, StrLength
, DevName
);
2572 Dev
->NameZ
= (CHAR8
*)AllocateZeroPool(StrLength
);
2573 UnicodeStrToAsciiStrS (DevName
, Dev
->NameZ
, StrLength
);
2576 // Retrieve bridge BDF info and port number or namespace depending on type
2579 Status
= gBS
->OpenProtocol(
2581 &gEfiDevicePathProtocolGuid
,
2582 (VOID
**)&TmpDevPath
,
2585 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2587 if (!EFI_ERROR(Status
)) {
2588 Dev
->OpalDevicePath
= DuplicateDevicePath (TmpDevPath
);
2592 if (Dev
->Name16
!= NULL
) {
2593 FreePool(Dev
->Name16
);
2596 if (Dev
->NameZ
!= NULL
) {
2597 FreePool(Dev
->NameZ
);
2608 Get devcie name through the component name protocol.
2610 @param[in] Dev The device which need to get name.
2612 @retval TRUE Find the name for this device.
2613 @retval FALSE Not found the name for this device.
2616 OpalDriverGetDriverDeviceName(
2617 OPAL_DRIVER_DEVICE
*Dev
2620 EFI_HANDLE
* AllHandlesBuffer
;
2621 UINTN NumAllHandles
;
2625 DEBUG((DEBUG_ERROR
| DEBUG_INIT
, "OpalDriverGetDriverDeviceName Exiting, Dev=NULL\n"));
2630 // Iterate through ComponentName2 handles to get name, if fails, try ComponentName
2632 if (Dev
->Name16
== NULL
) {
2633 DEBUG((DEBUG_ERROR
| DEBUG_INIT
, "Name is null, update it\n"));
2635 // Find all EFI_HANDLES
2637 Status
= gBS
->LocateHandleBuffer(
2644 if (EFI_ERROR(Status
)) {
2645 DEBUG ((DEBUG_INFO
, "LocateHandleBuffer for AllHandles failed %r\n", Status
));
2650 // Try component Name2
2652 if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer
, NumAllHandles
, Dev
, FALSE
)) {
2653 DEBUG((DEBUG_ERROR
| DEBUG_INIT
, "ComponentName2 failed to get device name, try ComponentName\n"));
2654 if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer
, NumAllHandles
, Dev
, TRUE
)) {
2655 DEBUG((DEBUG_ERROR
| DEBUG_INIT
, "ComponentName failed to get device name, skip device\n"));
2665 Main entry for this driver.
2667 @param ImageHandle Image Handle this driver.
2668 @param SystemTable Pointer to SystemTable.
2670 @retval EFI_SUCESS This function always complete successfully.
2674 EfiDriverEntryPoint(
2675 IN EFI_HANDLE ImageHandle
,
2676 IN EFI_SYSTEM_TABLE
* SystemTable
2680 EFI_EVENT ReadyToBootEvent
;
2681 EFI_EVENT EndOfDxeEvent
;
2683 Status
= EfiLibInstallDriverBindingComponentName2 (
2686 &gOpalDriverBinding
,
2688 &gOpalComponentName
,
2689 &gOpalComponentName2
2692 if (EFI_ERROR(Status
)) {
2693 DEBUG((DEBUG_ERROR
, "Install protocols to Opal driver Handle failed\n"));
2698 // Initialize Driver object
2700 ZeroMem(&mOpalDriver
, sizeof(mOpalDriver
));
2701 mOpalDriver
.Handle
= ImageHandle
;
2703 Status
= gBS
->CreateEventEx (
2706 OpalEndOfDxeEventNotify
,
2708 &gEfiEndOfDxeEventGroupGuid
,
2711 ASSERT_EFI_ERROR (Status
);
2714 // register a ReadyToBoot event callback for sending BlockSid command
2716 Status
= EfiCreateEventReadyToBootEx (
2718 ReadyToBootCallback
,
2719 (VOID
*) &ImageHandle
,
2724 // Install Hii packages.
2732 Tests to see if this driver supports a given controller.
2734 This function checks to see if the controller contains an instance of the
2735 EFI_STORAGE_SECURITY_COMMAND_PROTOCOL and the EFI_BLOCK_IO_PROTOCL
2736 and returns EFI_SUCCESS if it does.
2738 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
2739 @param[in] ControllerHandle The Handle of the controller to test. This Handle
2740 must support a protocol interface that supplies
2741 an I/O abstraction to the driver.
2742 @param[in] RemainingDevicePath This parameter is ignored.
2744 @retval EFI_SUCCESS The device contains required protocols
2745 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
2746 RemainingDevicePath is already being managed by the driver
2748 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
2749 RemainingDevicePath is already being managed by a different
2750 driver or an application that requires exclusive access.
2751 Currently not implemented.
2752 @retval EFI_UNSUPPORTED The device does not contain requires protocols
2757 OpalEfiDriverBindingSupported(
2758 IN EFI_DRIVER_BINDING_PROTOCOL
* This
,
2759 IN EFI_HANDLE Controller
,
2760 IN EFI_DEVICE_PATH_PROTOCOL
* RemainingDevicePath
2764 EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
* SecurityCommand
;
2765 EFI_BLOCK_IO_PROTOCOL
* BlkIo
;
2767 if (mOpalEndOfDxe
) {
2768 return EFI_UNSUPPORTED
;
2772 // Test EFI_STORAGE_SECURITY_COMMAND_PROTOCOL on controller Handle.
2774 Status
= gBS
->OpenProtocol(
2776 &gEfiStorageSecurityCommandProtocolGuid
,
2777 ( VOID
** )&SecurityCommand
,
2778 This
->DriverBindingHandle
,
2780 EFI_OPEN_PROTOCOL_BY_DRIVER
2783 if (Status
== EFI_ALREADY_STARTED
) {
2787 if (EFI_ERROR(Status
)) {
2792 // Close protocol and reopen in Start call
2796 &gEfiStorageSecurityCommandProtocolGuid
,
2797 This
->DriverBindingHandle
,
2802 // Test EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
2805 Status
= gBS
->OpenProtocol(
2807 &gEfiBlockIoProtocolGuid
,
2809 This
->DriverBindingHandle
,
2811 EFI_OPEN_PROTOCOL_BY_DRIVER
2814 if (EFI_ERROR(Status
)) {
2815 DEBUG((DEBUG_INFO
, "No EFI_BLOCK_IO_PROTOCOL on controller\n"));
2820 // Close protocol and reopen in Start call
2824 &gEfiBlockIoProtocolGuid
,
2825 This
->DriverBindingHandle
,
2833 Enables Opal Management on a supported device if available.
2835 The start function is designed to be called after the Opal UEFI Driver has confirmed the
2836 "controller", which is a child Handle, contains the EF_STORAGE_SECURITY_COMMAND protocols.
2837 This function will complete the other necessary checks, such as verifying the device supports
2838 the correct version of Opal. Upon verification, it will add the device to the
2839 Opal HII list in order to expose Opal managmeent options.
2841 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
2842 @param[in] ControllerHandle The Handle of the controller to start. This Handle
2843 must support a protocol interface that supplies
2844 an I/O abstraction to the driver.
2845 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
2846 parameter is ignored by device drivers, and is optional for bus
2847 drivers. For a bus driver, if this parameter is NULL, then handles
2848 for all the children of Controller are created by this driver.
2849 If this parameter is not NULL and the first Device Path Node is
2850 not the End of Device Path Node, then only the Handle for the
2851 child device specified by the first Device Path Node of
2852 RemainingDevicePath is created by this driver.
2853 If the first Device Path Node of RemainingDevicePath is
2854 the End of Device Path Node, no child Handle is created by this
2857 @retval EFI_SUCCESS Opal management was enabled.
2858 @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
2859 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
2860 @retval Others The driver failed to start the device.
2865 OpalEfiDriverBindingStart(
2866 IN EFI_DRIVER_BINDING_PROTOCOL
* This
,
2867 IN EFI_HANDLE Controller
,
2868 IN EFI_DEVICE_PATH_PROTOCOL
* RemainingDevicePath
2872 EFI_BLOCK_IO_PROTOCOL
*BlkIo
;
2873 OPAL_DRIVER_DEVICE
*Dev
;
2874 OPAL_DRIVER_DEVICE
*Itr
;
2877 Itr
= mOpalDriver
.DeviceList
;
2878 while (Itr
!= NULL
) {
2879 if (Controller
== Itr
->Handle
) {
2886 // Create internal device for tracking. This allows all disks to be tracked
2889 Dev
= (OPAL_DRIVER_DEVICE
*)AllocateZeroPool(sizeof(OPAL_DRIVER_DEVICE
));
2891 return EFI_OUT_OF_RESOURCES
;
2893 Dev
->Handle
= Controller
;
2896 // Open EFI_STORAGE_SECURITY_COMMAND_PROTOCOL to perform Opal supported checks
2898 Status
= gBS
->OpenProtocol(
2900 &gEfiStorageSecurityCommandProtocolGuid
,
2901 (VOID
**)&Dev
->Sscp
,
2902 This
->DriverBindingHandle
,
2904 EFI_OPEN_PROTOCOL_BY_DRIVER
2906 if (EFI_ERROR(Status
)) {
2912 // Open EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
2915 Status
= gBS
->OpenProtocol(
2917 &gEfiBlockIoProtocolGuid
,
2919 This
->DriverBindingHandle
,
2921 EFI_OPEN_PROTOCOL_BY_DRIVER
2923 if (EFI_ERROR(Status
)) {
2925 // Close storage security that was opened
2929 &gEfiStorageSecurityCommandProtocolGuid
,
2930 This
->DriverBindingHandle
,
2941 Dev
->MediaId
= BlkIo
->Media
->MediaId
;
2945 &gEfiBlockIoProtocolGuid
,
2946 This
->DriverBindingHandle
,
2951 // Acquire Ascii printable name of child, if not found, then ignore device
2953 Result
= OpalDriverGetDriverDeviceName (Dev
);
2958 Status
= OpalDiskInitialize (Dev
);
2959 if (EFI_ERROR (Status
)) {
2963 AddDeviceToTail(Dev
);
2966 // Check if device is locked and prompt for password.
2968 OpalDriverRequestPassword (Dev
, L
"Unlock:");
2971 // Process OPAL request from last boot.
2973 ProcessOpalRequest (Dev
);
2979 // free device, close protocols and exit
2983 &gEfiStorageSecurityCommandProtocolGuid
,
2984 This
->DriverBindingHandle
,
2990 return EFI_DEVICE_ERROR
;
2994 Stop this driver on Controller.
2996 @param This Protocol instance pointer.
2997 @param Controller Handle of device to stop driver on
2998 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
2999 children is zero stop the entire bus driver.
3000 @param ChildHandleBuffer List of Child Handles to Stop.
3002 @retval EFI_SUCCESS This driver is removed Controller.
3003 @retval other This driver could not be removed from this device.
3008 OpalEfiDriverBindingStop(
3009 EFI_DRIVER_BINDING_PROTOCOL
* This
,
3010 EFI_HANDLE Controller
,
3011 UINTN NumberOfChildren
,
3012 EFI_HANDLE
* ChildHandleBuffer
3015 OPAL_DRIVER_DEVICE
* Itr
;
3017 Itr
= mOpalDriver
.DeviceList
;
3020 // does Controller match any of the devices we are managing for Opal
3022 while (Itr
!= NULL
) {
3023 if (Itr
->Handle
== Controller
) {
3024 OpalDriverStopDevice (Itr
);
3031 return EFI_NOT_FOUND
;
3036 Unloads UEFI Driver. Very useful for debugging and testing.
3038 @param ImageHandle Image Handle this driver.
3040 @retval EFI_SUCCESS This function always complete successfully.
3041 @retval EFI_INVALID_PARAMETER The input ImageHandle is not valid.
3045 OpalEfiDriverUnload (
3046 IN EFI_HANDLE ImageHandle
3050 OPAL_DRIVER_DEVICE
*Itr
;
3052 Status
= EFI_SUCCESS
;
3054 if (ImageHandle
!= gImageHandle
) {
3055 return (EFI_INVALID_PARAMETER
);
3059 // Uninstall any interface added to each device by us
3061 while (mOpalDriver
.DeviceList
) {
3062 Itr
= mOpalDriver
.DeviceList
;
3064 // Remove OPAL_DRIVER_DEVICE from the list
3065 // it updates the controllerList pointer
3067 OpalDriverStopDevice(Itr
);
3071 // Uninstall the HII capability
3073 Status
= HiiUninstall();