[mirror_edk2.git] / SecurityPkg / Tcg / Opal / OpalPasswordDxe / OpalDriver.c

/** @file\r
  Entrypoint of Opal UEFI Driver and contains all the logic to\r
  register for new Opal device instances.\r
\r
Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
// This UEFI driver consumes EFI_STORAGE_SECURITY_PROTOCOL instances and installs an\r
// HII GUI to manage Opal features if the device is Opal capable\r
// If the Opal device is being managed by the UEFI Driver, it shall provide a popup\r
// window during boot requesting a user password\r
\r
#include "OpalDriver.h"\r
#include "OpalDriverPrivate.h"\r
#include "OpalHii.h"\r
\r
OPAL_DRIVER mOpalDriver;\r
\r
#define MAX_PASSWORD_SIZE        32\r
#define MAX_PASSWORD_TRY_COUNT   5\r
\r
//\r
// Globals\r
//\r
EFI_DRIVER_BINDING_PROTOCOL gOpalDriverBinding = {\r
  OpalEfiDriverBindingSupported,\r
  OpalEfiDriverBindingStart,\r
  OpalEfiDriverBindingStop,\r
  0x1b,\r
  NULL,\r
  NULL\r
};\r
\r
\r
/**\r
  Add new device to the global device list.\r
\r
  @param Dev             New create device.\r
\r
**/\r
VOID\r
AddDeviceToTail(\r
  IN OPAL_DRIVER_DEVICE    *Dev\r
  )\r
{\r
  OPAL_DRIVER_DEVICE                *TmpDev;\r
\r
  if (mOpalDriver.DeviceList == NULL) {\r
    mOpalDriver.DeviceList = Dev;\r
  } else {\r
    TmpDev = mOpalDriver.DeviceList;\r
    while (TmpDev->Next != NULL) {\r
      TmpDev = TmpDev->Next;\r
    }\r
\r
    TmpDev->Next = Dev;\r
  }\r
}\r
\r
/**\r
  Remove one device in the global device list.\r
\r
  @param Dev             The device need to be removed.\r
\r
**/\r
VOID\r
RemoveDevice (\r
  IN OPAL_DRIVER_DEVICE    *Dev\r
  )\r
{\r
  OPAL_DRIVER_DEVICE                *TmpDev;\r
\r
  if (mOpalDriver.DeviceList == NULL) {\r
    return;\r
  }\r
\r
  if (mOpalDriver.DeviceList == Dev) {\r
    mOpalDriver.DeviceList = NULL;\r
    return;\r
  }\r
\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev->Next != NULL) {\r
    if (TmpDev->Next == Dev) {\r
      TmpDev->Next = Dev->Next;\r
      break;\r
    }\r
  }\r
}\r
\r
/**\r
  Get current device count.\r
\r
  @retval  return the current created device count.\r
\r
**/\r
UINT8\r
GetDeviceCount (\r
  VOID\r
  )\r
{\r
  UINT8                Count;\r
  OPAL_DRIVER_DEVICE   *TmpDev;\r
\r
  Count = 0;\r
  TmpDev = mOpalDriver.DeviceList;\r
\r
  while (TmpDev != NULL) {\r
    Count++;\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  return Count;\r
}\r
\r
/**\r
  Get password input from the popup windows, and unlock the device.\r
\r
  @param[in]       Dev          The device which need to be unlock.\r
  @param[out]      PressEsc     Whether user escape function through Press ESC.\r
\r
  @retval   Password string if success. NULL if failed.\r
\r
**/\r
CHAR8 *\r
OpalDriverPopUpHddPassword (\r
  IN  OPAL_DRIVER_DEVICE         *Dev,\r
  OUT BOOLEAN                    *PressEsc\r
  )\r
{\r
  EFI_INPUT_KEY                InputKey;\r
  UINTN                        InputLength;\r
  CHAR16                       Mask[MAX_PASSWORD_SIZE + 1];\r
  CHAR16                       Unicode[MAX_PASSWORD_SIZE + 1];\r
  CHAR8                        *Ascii;\r
  CHAR16                       *PopUpString;\r
  UINTN                        StrLength;\r
\r
  ZeroMem(Unicode, sizeof(Unicode));\r
  ZeroMem(Mask, sizeof(Mask));\r
\r
  StrLength = StrLen(Dev->Name16);\r
  PopUpString = (CHAR16*) AllocateZeroPool ((8 + StrLength) * 2);\r
  *PressEsc = FALSE;\r
\r
  if (Dev->Name16 == NULL) {\r
    UnicodeSPrint(PopUpString, StrLen(L"Unlock Disk") + 1, L"Unlock Disk");\r
  } else {\r
    UnicodeSPrint(PopUpString, StrLen(L"Unlock ") + StrLength + 1, L"Unlock %s", Dev->Name16);\r
  }\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  InputLength = 0;\r
  while (TRUE) {\r
    Mask[InputLength] = L'_';\r
    CreatePopUp(\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &InputKey,\r
        PopUpString,\r
        L"---------------------",\r
        Mask,\r
        NULL\r
    );\r
\r
    //\r
    // Check key.\r
    //\r
    if (InputKey.ScanCode == SCAN_NULL) {\r
      //\r
      // password finished\r
      //\r
      if (InputKey.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
        //\r
        // Add the null terminator.\r
        //\r
        Unicode[InputLength] = 0;\r
        InputLength++;\r
        break;\r
      } else if ((InputKey.UnicodeChar == CHAR_NULL) ||\r
                 (InputKey.UnicodeChar == CHAR_TAB) ||\r
                 (InputKey.UnicodeChar == CHAR_LINEFEED)\r
                ) {\r
        continue;\r
      } else {\r
        //\r
        // delete last key entered\r
        //\r
        if (InputKey.UnicodeChar == CHAR_BACKSPACE) {\r
          if (InputLength > 0) {\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            InputLength--;\r
          }\r
        } else {\r
          //\r
          // add Next key entry\r
          //\r
          Unicode[InputLength] = InputKey.UnicodeChar;\r
          Mask[InputLength] = L'*';\r
          InputLength++;\r
          if (InputLength == MAX_PASSWORD_SIZE) {\r
            //\r
            // Add the null terminator.\r
            //\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            break;\r
          }\r
        }\r
      }\r
    }\r
\r
    //\r
    // exit on ESC\r
    //\r
    if (InputKey.ScanCode == SCAN_ESC) {\r
      *PressEsc = TRUE;\r
      break;\r
    }\r
  }\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  if (InputLength == 0 || InputKey.ScanCode == SCAN_ESC) {\r
    return NULL;\r
  }\r
\r
  Ascii = AllocateZeroPool (MAX_PASSWORD_SIZE + 1);\r
  if (Ascii == NULL) {\r
    return NULL;\r
  }\r
\r
  UnicodeStrToAsciiStr(Unicode, Ascii);\r
\r
  return Ascii;\r
}\r
\r
/**\r
  Check if disk is locked, show popup window and ask for password if it is\r
\r
  @param[in]       Dev          The device which need to be unlock.\r
\r
**/\r
VOID\r
OpalDriverRequestPassword (\r
  OPAL_DRIVER_DEVICE       *Dev\r
  )\r
{\r
  UINT8               Count;\r
  BOOLEAN             IsEnabled;\r
  CHAR8               *Password;\r
  UINT32              PasswordLen;\r
  TCG_RESULT          Ret;\r
  EFI_INPUT_KEY       Key;\r
  OPAL_SESSION        Session;\r
  BOOLEAN             PressEsc;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  Count = 0;\r
\r
  IsEnabled = OpalFeatureEnabled (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature);\r
  if (IsEnabled) {\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
    while (Count < MAX_PASSWORD_TRY_COUNT) {\r
      Password = OpalDriverPopUpHddPassword (Dev, &PressEsc);\r
      if (PressEsc) {\r
        //\r
        // User not input password and press ESC, keep device in lock status and continue boot.\r
        //\r
        do {\r
          CreatePopUp (\r
                  EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
                  &Key,\r
                  L"Confirm: Not unlock device and continue boot?.",\r
                  L"Press ENTER to confirm, Press Esc to input password",\r
                  NULL\r
                  );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          //\r
          // Keep lock and continue boot.\r
          //\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
      }\r
\r
      if (Password == NULL) {\r
        Count ++;\r
        continue;\r
      }\r
      PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
      if (OpalDeviceLocked (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature)) {\r
        Ret = OpalSupportUnlock(&Session, Password, PasswordLen, Dev->OpalDevicePath);\r
      } else {\r
        Ret = OpalSupportLock(&Session, Password, PasswordLen, Dev->OpalDevicePath);\r
        if (Ret == TcgResultSuccess) {\r
          Ret = OpalSupportUnlock(&Session, Password, PasswordLen, Dev->OpalDevicePath);\r
        }\r
      }\r
\r
      if (Password != NULL) {\r
        ZeroMem (Password, PasswordLen);\r
        FreePool (Password);\r
      }\r
\r
      if (Ret == TcgResultSuccess) {\r
        break;\r
      }\r
\r
      Count++;\r
\r
      do {\r
        CreatePopUp (\r
                  EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
                  &Key,\r
                  L"Invalid password.",\r
                  L"Press ENTER to retry",\r
                  NULL\r
                  );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    }\r
\r
    if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
      do {\r
        CreatePopUp (\r
                EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
                &Key,\r
                L"Opal password retry count is expired. Keep lock and continue boot.",\r
                L"Press ENTER to continue",\r
                NULL\r
                );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
      gST->ConOut->ClearScreen(gST->ConOut);\r
    }\r
  }\r
}\r
\r
/**\r
  Get devcie list info.\r
\r
  @retval     return the device list pointer.\r
**/\r
OPAL_DRIVER_DEVICE*\r
OpalDriverGetDeviceList(\r
  VOID\r
  )\r
{\r
  return mOpalDriver.DeviceList;\r
}\r
\r
/**\r
  ReadyToBoot callback to send BlockSid command.\r
\r
  @param  Event   Pointer to this event\r
  @param  Context Event hanlder private Data\r
\r
**/\r
VOID\r
EFIAPI\r
ReadyToBootCallback (\r
  IN EFI_EVENT        Event,\r
  IN VOID             *Context\r
  )\r
{\r
  EFI_STATUS          Status;\r
  OPAL_DRIVER_DEVICE* Itr;\r
  TCG_RESULT          Result;\r
  OPAL_EXTRA_INFO_VAR OpalExtraInfo;\r
  UINTN               DataSize;\r
  OPAL_SESSION        Session;\r
\r
  gBS->CloseEvent (Event);\r
\r
  DataSize = sizeof (OPAL_EXTRA_INFO_VAR);\r
  Status = gRT->GetVariable (\r
                  OPAL_EXTRA_INFO_VAR_NAME,\r
                  &gOpalExtraInfoVariableGuid,\r
                  NULL,\r
                  &DataSize,\r
                  &OpalExtraInfo\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return;\r
  }\r
\r
  if (OpalExtraInfo.EnableBlockSid == TRUE) {\r
    //\r
    // Send BlockSID command to each Opal disk\r
    //\r
    Itr = mOpalDriver.DeviceList;\r
    while (Itr != NULL) {\r
      if (Itr->OpalDisk.SupportedAttributes.BlockSid) {\r
        ZeroMem(&Session, sizeof(Session));\r
        Session.Sscp = Itr->OpalDisk.Sscp;\r
        Session.MediaId = Itr->OpalDisk.MediaId;\r
        Session.OpalBaseComId = Itr->OpalDisk.OpalBaseComId;\r
\r
        Result = OpalBlockSid (&Session, TRUE);  // HardwareReset must always be TRUE\r
        if (Result != TcgResultSuccess) {\r
          DEBUG ((DEBUG_ERROR, "OpalBlockSid fail\n"));\r
          break;\r
        }\r
      }\r
\r
      Itr = Itr->Next;\r
    }\r
  }\r
}\r
\r
/**\r
  Stop this Controller.\r
\r
  @param  Dev               The device need to be stopped.\r
\r
**/\r
VOID\r
OpalDriverStopDevice (\r
  OPAL_DRIVER_DEVICE     *Dev\r
  )\r
{\r
  //\r
  // free each name\r
  //\r
  FreePool(Dev->Name16);\r
\r
  //\r
  // remove OPAL_DRIVER_DEVICE from the list\r
  // it updates the controllerList pointer\r
  //\r
  RemoveDevice(Dev);\r
\r
  //\r
  // close protocols that were opened\r
  //\r
  gBS->CloseProtocol(\r
    Dev->Handle,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    gOpalDriverBinding.DriverBindingHandle,\r
    Dev->Handle\r
    );\r
\r
  gBS->CloseProtocol(\r
    Dev->Handle,\r
    &gEfiBlockIoProtocolGuid,\r
    gOpalDriverBinding.DriverBindingHandle,\r
    Dev->Handle\r
    );\r
\r
  FreePool(Dev);\r
}\r
\r
/**\r
  Get devcie name through the component name protocol.\r
\r
  @param[in]       AllHandlesBuffer   The handle buffer for current system.\r
  @param[in]       NumAllHandles      The number of handles for the handle buffer.\r
  @param[in]       Dev                The device which need to get name.\r
  @param[in]       UseComp1           Whether use component name or name2 protocol.\r
\r
  @retval     TRUE        Find the name for this device.\r
  @retval     FALSE       Not found the name for this device.\r
**/\r
BOOLEAN\r
OpalDriverGetDeviceNameByProtocol(\r
  EFI_HANDLE             *AllHandlesBuffer,\r
  UINTN                  NumAllHandles,\r
  OPAL_DRIVER_DEVICE     *Dev,\r
  BOOLEAN                UseComp1\r
  )\r
{\r
  EFI_HANDLE*                   ProtocolHandlesBuffer;\r
  UINTN                         NumProtocolHandles;\r
  EFI_STATUS                    Status;\r
  EFI_COMPONENT_NAME2_PROTOCOL* Cnp1_2; // efi component name and componentName2 have same layout\r
  EFI_GUID                      Protocol;\r
  UINTN                         StrLength;\r
  EFI_DEVICE_PATH_PROTOCOL*     TmpDevPath;\r
  UINTN                         Index1;\r
  UINTN                         Index2;\r
  EFI_HANDLE                    TmpHandle;\r
  CHAR16                        *DevName;\r
\r
  if (Dev == NULL || AllHandlesBuffer == NULL || NumAllHandles == 0) {\r
    return FALSE;\r
  }\r
\r
  Protocol = UseComp1 ? gEfiComponentNameProtocolGuid : gEfiComponentName2ProtocolGuid;\r
\r
  //\r
  // Find all EFI_HANDLES with protocol\r
  //\r
  Status = gBS->LocateHandleBuffer(\r
               ByProtocol,\r
               &Protocol,\r
               NULL,\r
               &NumProtocolHandles,\r
               &ProtocolHandlesBuffer\r
               );\r
  if (EFI_ERROR(Status)) {\r
    return FALSE;\r
  }\r
\r
\r
  //\r
  // Exit early if no supported devices\r
  //\r
  if (NumProtocolHandles == 0) {\r
    return FALSE;\r
  }\r
\r
  //\r
  // Get printable name by iterating through all protocols\r
  // using the handle as the child, and iterate through all handles for the controller\r
  // exit loop early once found, if not found, then delete device\r
  // storage security protocol instances already exist, add them to internal list\r
  //\r
  Status = EFI_DEVICE_ERROR;\r
  for (Index1 = 0; Index1 < NumProtocolHandles; Index1++) {\r
    DevName = NULL;\r
\r
    if (Dev->Name16 != NULL) {\r
      return TRUE;\r
    }\r
\r
    TmpHandle = ProtocolHandlesBuffer[Index1];\r
\r
    Status = gBS->OpenProtocol(\r
                 TmpHandle,\r
                 &Protocol,\r
                 (VOID**)&Cnp1_2,\r
                 gImageHandle,\r
                 NULL,\r
                 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                 );\r
    if (EFI_ERROR(Status) || Cnp1_2 == NULL) {\r
      continue;\r
    }\r
\r
    //\r
    // Use all handles array as controller handle\r
    //\r
    for (Index2 = 0; Index2 < NumAllHandles; Index2++) {\r
      Status = Cnp1_2->GetControllerName(\r
                   Cnp1_2,\r
                   AllHandlesBuffer[Index2],\r
                   Dev->Handle,\r
                   LANGUAGE_ISO_639_2_ENGLISH,\r
                   &DevName\r
                   );\r
      if (EFI_ERROR(Status)) {\r
        Status = Cnp1_2->GetControllerName(\r
                     Cnp1_2,\r
                     AllHandlesBuffer[Index2],\r
                     Dev->Handle,\r
                     LANGUAGE_RFC_3066_ENGLISH,\r
                     &DevName\r
                     );\r
      }\r
      if (!EFI_ERROR(Status) && DevName != NULL) {\r
        StrLength = StrLen(DevName) + 1;        // Add one for NULL terminator\r
        Dev->Name16 = AllocateZeroPool(StrLength * sizeof (CHAR16));\r
        ASSERT (Dev->Name16 != NULL);\r
        StrCpyS (Dev->Name16, StrLength, DevName);\r
        Dev->NameZ = (CHAR8*)AllocateZeroPool(StrLength);\r
        UnicodeStrToAsciiStr(DevName, Dev->NameZ);\r
\r
        //\r
        // Retrieve bridge BDF info and port number or namespace depending on type\r
        //\r
        TmpDevPath = NULL;\r
        Status = gBS->OpenProtocol(\r
            Dev->Handle,\r
            &gEfiDevicePathProtocolGuid,\r
            (VOID**)&TmpDevPath,\r
            gImageHandle,\r
            NULL,\r
            EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
            );\r
        if (!EFI_ERROR(Status)) {\r
          Dev->OpalDevicePath = DuplicateDevicePath (TmpDevPath);\r
          return TRUE;\r
        }\r
\r
        if (Dev->Name16 != NULL) {\r
          FreePool(Dev->Name16);\r
          Dev->Name16 = NULL;\r
        }\r
        if (Dev->NameZ != NULL) {\r
          FreePool(Dev->NameZ);\r
          Dev->NameZ = NULL;\r
        }\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Get devcie name through the component name protocol.\r
\r
  @param[in]       Dev                The device which need to get name.\r
\r
  @retval     TRUE        Find the name for this device.\r
  @retval     FALSE       Not found the name for this device.\r
**/\r
BOOLEAN\r
OpalDriverGetDriverDeviceName(\r
  OPAL_DRIVER_DEVICE          *Dev\r
  )\r
{\r
  EFI_HANDLE*                  AllHandlesBuffer;\r
  UINTN                        NumAllHandles;\r
  EFI_STATUS                   Status;\r
\r
  if (Dev == NULL) {\r
    DEBUG((DEBUG_ERROR | DEBUG_INIT, "OpalDriverGetDriverDeviceName Exiting, Dev=NULL\n"));\r
    return FALSE;\r
  }\r
\r
  //\r
  // Iterate through ComponentName2 handles to get name, if fails, try ComponentName\r
  //\r
  if (Dev->Name16 == NULL) {\r
    DEBUG((DEBUG_ERROR | DEBUG_INIT, "Name is null, update it\n"));\r
    //\r
    // Find all EFI_HANDLES\r
    //\r
    Status = gBS->LocateHandleBuffer(\r
                 AllHandles,\r
                 NULL,\r
                 NULL,\r
                 &NumAllHandles,\r
                 &AllHandlesBuffer\r
                 );\r
    if (EFI_ERROR(Status)) {\r
      DEBUG ((DEBUG_INFO, "LocateHandleBuffer for AllHandles failed %r\n", Status ));\r
      return FALSE;\r
    }\r
\r
    //\r
    // Try component Name2\r
    //\r
    if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, FALSE)) {\r
      DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName2 failed to get device name, try ComponentName\n"));\r
      if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, TRUE)) {\r
        DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName failed to get device name, skip device\n"));\r
        return FALSE;\r
      }\r
    }\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Main entry for this driver.\r
\r
  @param ImageHandle     Image Handle this driver.\r
  @param SystemTable     Pointer to SystemTable.\r
\r
  @retval EFI_SUCESS     This function always complete successfully.\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiDriverEntryPoint(\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE*  SystemTable\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  EFI_EVENT                      ReadyToBootEvent;\r
\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gOpalDriverBinding,\r
             ImageHandle,\r
             &gOpalComponentName,\r
             &gOpalComponentName2\r
             );\r
\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((DEBUG_ERROR, "Install protocols to Opal driver Handle failed\n"));\r
    return Status ;\r
  }\r
\r
  //\r
  // Initialize Driver object\r
  //\r
  ZeroMem(&mOpalDriver, sizeof(mOpalDriver));\r
  mOpalDriver.Handle = ImageHandle;\r
\r
  //\r
  // register a ReadyToBoot event callback for sending BlockSid command\r
  //\r
  Status = EfiCreateEventReadyToBootEx (\r
                  TPL_CALLBACK,\r
                  ReadyToBootCallback,\r
                  (VOID *) &ImageHandle,\r
                  &ReadyToBootEvent\r
                  );\r
\r
  //\r
  // Install Hii packages.\r
  //\r
  HiiInstall();\r
\r
  return Status;\r
}\r
\r
/**\r
  Tests to see if this driver supports a given controller.\r
\r
  This function checks to see if the controller contains an instance of the\r
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL and the EFI_BLOCK_IO_PROTOCL\r
  and returns EFI_SUCCESS if it does.\r
\r
  @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle      The Handle of the controller to test. This Handle\r
                                    must support a protocol interface that supplies\r
                                    an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath  This parameter is ignored.\r
\r
  @retval EFI_SUCCESS               The device contains required protocols\r
  @retval EFI_ALREADY_STARTED       The device specified by ControllerHandle and\r
                                    RemainingDevicePath is already being managed by the driver\r
                                    specified by This.\r
  @retval EFI_ACCESS_DENIED         The device specified by ControllerHandle and\r
                                    RemainingDevicePath is already being managed by a different\r
                                    driver or an application that requires exclusive access.\r
                                    Currently not implemented.\r
  @retval EFI_UNSUPPORTED           The device does not contain requires protocols\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingSupported(\r
  IN EFI_DRIVER_BINDING_PROTOCOL* This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                              Status;\r
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL*  SecurityCommand;\r
  EFI_BLOCK_IO_PROTOCOL*                  BlkIo;\r
\r
  //\r
  // Test EFI_STORAGE_SECURITY_COMMAND_PROTOCOL on controller Handle.\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    ( VOID ** )&SecurityCommand,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
\r
  if (Status == EFI_ALREADY_STARTED) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocol and reopen in Start call\r
  //\r
  gBS->CloseProtocol(\r
      Controller,\r
      &gEfiStorageSecurityCommandProtocolGuid,\r
      This->DriverBindingHandle,\r
      Controller\r
      );\r
\r
  //\r
  // Test EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL\r
  // function APIs\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    (VOID **)&BlkIo,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((DEBUG_INFO, "No EFI_BLOCK_IO_PROTOCOL on controller\n"));\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocol and reopen in Start call\r
  //\r
  gBS->CloseProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    This->DriverBindingHandle,\r
    Controller\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Enables Opal Management on a supported device if available.\r
\r
  The start function is designed to be called after the Opal UEFI Driver has confirmed the\r
  "controller", which is a child Handle, contains the EF_STORAGE_SECURITY_COMMAND protocols.\r
  This function will complete the other necessary checks, such as verifying the device supports\r
  the correct version of Opal.  Upon verification, it will add the device to the\r
  Opal HII list in order to expose Opal managmeent options.\r
\r
  @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle      The Handle of the controller to start. This Handle\r
                                    must support a protocol interface that supplies\r
                                    an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath   A pointer to the remaining portion of a device path.  This\r
                                    parameter is ignored by device drivers, and is optional for bus\r
                                    drivers. For a bus driver, if this parameter is NULL, then handles\r
                                    for all the children of Controller are created by this driver.\r
                                    If this parameter is not NULL and the first Device Path Node is\r
                                    not the End of Device Path Node, then only the Handle for the\r
                                    child device specified by the first Device Path Node of\r
                                    RemainingDevicePath is created by this driver.\r
                                    If the first Device Path Node of RemainingDevicePath is\r
                                    the End of Device Path Node, no child Handle is created by this\r
                                    driver.\r
\r
  @retval EFI_SUCCESS               Opal management was enabled.\r
  @retval EFI_DEVICE_ERROR          The device could not be started due to a device error.Currently not implemented.\r
  @retval EFI_OUT_OF_RESOURCES      The request could not be completed due to a lack of resources.\r
  @retval Others                    The driver failed to start the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingStart(\r
  IN EFI_DRIVER_BINDING_PROTOCOL* This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_BLOCK_IO_PROTOCOL       *BlkIo;\r
  OPAL_DRIVER_DEVICE          *Dev;\r
  OPAL_DRIVER_DEVICE          *Itr;\r
  BOOLEAN                     Result;\r
\r
  Itr = mOpalDriver.DeviceList;\r
  while (Itr != NULL) {\r
    if (Controller == Itr->Handle) {\r
      return EFI_SUCCESS;\r
    }\r
    Itr = Itr->Next;\r
  }\r
\r
  //\r
  // Create internal device for tracking.  This allows all disks to be tracked\r
  // by same HII form\r
  //\r
  Dev = (OPAL_DRIVER_DEVICE*)AllocateZeroPool(sizeof(OPAL_DRIVER_DEVICE));\r
  if (Dev == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  Dev->Handle = Controller;\r
\r
  //\r
  // Open EFI_STORAGE_SECURITY_COMMAND_PROTOCOL to perform Opal supported checks\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    (VOID **)&Dev->Sscp,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
  if (EFI_ERROR(Status)) {\r
    FreePool(Dev);\r
    return Status;\r
  }\r
\r
  //\r
  // Open EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL\r
  // function APIs\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    (VOID **)&BlkIo,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
  if (EFI_ERROR(Status)) {\r
    //\r
    // Close storage security that was opened\r
    //\r
    gBS->CloseProtocol(\r
        Controller,\r
        &gEfiStorageSecurityCommandProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
    FreePool(Dev);\r
    return Status;\r
  }\r
\r
  //\r
  // Save mediaId\r
  //\r
  Dev->MediaId = BlkIo->Media->MediaId;\r
\r
  gBS->CloseProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    This->DriverBindingHandle,\r
    Controller\r
    );\r
\r
  //\r
  // Acquire Ascii printable name of child, if not found, then ignore device\r
  //\r
  Result = OpalDriverGetDriverDeviceName (Dev);\r
  if (!Result) {\r
    goto Done;\r
  }\r
\r
  Status = OpalDiskInitialize (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  AddDeviceToTail(Dev);\r
\r
  //\r
  // check if device is locked and prompt for password\r
  //\r
  OpalDriverRequestPassword (Dev);\r
\r
  return EFI_SUCCESS;\r
\r
Done:\r
  //\r
  // free device, close protocols and exit\r
  //\r
  gBS->CloseProtocol(\r
      Controller,\r
      &gEfiStorageSecurityCommandProtocolGuid,\r
      This->DriverBindingHandle,\r
      Controller\r
      );\r
\r
  FreePool(Dev);\r
\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
/**\r
  Stop this driver on Controller.\r
\r
  @param  This              Protocol instance pointer.\r
  @param  Controller        Handle of device to stop driver on\r
  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of\r
                            children is zero stop the entire bus driver.\r
  @param  ChildHandleBuffer List of Child Handles to Stop.\r
\r
  @retval EFI_SUCCESS       This driver is removed Controller.\r
  @retval other             This driver could not be removed from this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingStop(\r
  EFI_DRIVER_BINDING_PROTOCOL*    This,\r
  EFI_HANDLE                      Controller,\r
  UINTN                           NumberOfChildren,\r
  EFI_HANDLE*                     ChildHandleBuffer\r
  )\r
{\r
  OPAL_DRIVER_DEVICE*   Itr;\r
\r
  Itr = mOpalDriver.DeviceList;\r
\r
  //\r
  // does Controller match any of the devices we are managing for Opal\r
  //\r
  while (Itr != NULL) {\r
    if (Itr->Handle == Controller) {\r
      OpalDriverStopDevice (Itr);\r
      return EFI_SUCCESS;\r
    }\r
\r
    Itr = Itr->Next;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
/**\r
  Unloads UEFI Driver.  Very useful for debugging and testing.\r
\r
  @param ImageHandle            Image Handle this driver.\r
\r
  @retval EFI_SUCCESS           This function always complete successfully.\r
  @retval EFI_INVALID_PARAMETER The input ImageHandle is not valid.\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverUnload (\r
  IN EFI_HANDLE ImageHandle\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  OPAL_DRIVER_DEVICE                   *Itr;\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (ImageHandle != gImageHandle) {\r
    return (EFI_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // Uninstall any interface added to each device by us\r
  //\r
  while (mOpalDriver.DeviceList) {\r
    Itr = mOpalDriver.DeviceList;\r
    //\r
    // Remove OPAL_DRIVER_DEVICE from the list\r
    // it updates the controllerList pointer\r
    //\r
    OpalDriverStopDevice(Itr);\r
  }\r
\r
  //\r
  // Uninstall the HII capability\r
  //\r
  Status = HiiUninstall();\r
\r
  return Status;\r
}\r
\r