SecurityPkg/Tcg/Opal/OpalPasswordDxe/OpalDriver.c

   1 /** @file
   2   Entrypoint of Opal UEFI Driver and contains all the logic to
   3   register for new Opal device instances.
   4
   5 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  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.
  13
  14 **/
  15
  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
  20
  21 #include "OpalDriver.h"
  22 #include "OpalDriverPrivate.h"
  23 #include "OpalHii.h"
  24
  25 OPAL_DRIVER mOpalDriver;
  26
  27 #define MAX_PASSWORD_SIZE        32
  28 #define MAX_PASSWORD_TRY_COUNT   5
  29
  30 //
  31 // Globals
  32 //
  33 EFI_DRIVER_BINDING_PROTOCOL gOpalDriverBinding = {
  34   OpalEfiDriverBindingSupported,
  35   OpalEfiDriverBindingStart,
  36   OpalEfiDriverBindingStop,
  37   0x1b,
  38   NULL,
  39   NULL
  40 };
  41
  42
  43 /**
  44   Add new device to the global device list.
  45
  46   @param Dev             New create device.
  47
  48 **/
  49 VOID
  50 AddDeviceToTail(
  51   IN OPAL_DRIVER_DEVICE    *Dev
  52   )
  53 {
  54   OPAL_DRIVER_DEVICE                *TmpDev;
  55
  56   if (mOpalDriver.DeviceList == NULL) {
  57     mOpalDriver.DeviceList = Dev;
  58   } else {
  59     TmpDev = mOpalDriver.DeviceList;
  60     while (TmpDev->Next != NULL) {
  61       TmpDev = TmpDev->Next;
  62     }
  63
  64     TmpDev->Next = Dev;
  65   }
  66 }
  67
  68 /**
  69   Remove one device in the global device list.
  70
  71   @param Dev             The device need to be removed.
  72
  73 **/
  74 VOID
  75 RemoveDevice (
  76   IN OPAL_DRIVER_DEVICE    *Dev
  77   )
  78 {
  79   OPAL_DRIVER_DEVICE                *TmpDev;
  80
  81   if (mOpalDriver.DeviceList == NULL) {
  82     return;
  83   }
  84
  85   if (mOpalDriver.DeviceList == Dev) {
  86     mOpalDriver.DeviceList = NULL;
  87     return;
  88   }
  89
  90   TmpDev = mOpalDriver.DeviceList;
  91   while (TmpDev->Next != NULL) {
  92     if (TmpDev->Next == Dev) {
  93       TmpDev->Next = Dev->Next;
  94       break;
  95     }
  96   }
  97 }
  98
  99 /**
 100   Get current device count.
 101
 102   @retval  return the current created device count.
 103
 104 **/
 105 UINT8
 106 GetDeviceCount (
 107   VOID
 108   )
 109 {
 110   UINT8                Count;
 111   OPAL_DRIVER_DEVICE   *TmpDev;
 112
 113   Count = 0;
 114   TmpDev = mOpalDriver.DeviceList;
 115
 116   while (TmpDev != NULL) {
 117     Count++;
 118     TmpDev = TmpDev->Next;
 119   }
 120
 121   return Count;
 122 }
 123
 124 /**
 125   Get password input from the popup windows, and unlock the device.
 126
 127   @param[in]       Dev          The device which need to be unlock.
 128   @param[out]      PressEsc     Whether user escape function through Press ESC.
 129
 130   @retval   Password string if success. NULL if failed.
 131
 132 **/
 133 CHAR8 *
 134 OpalDriverPopUpHddPassword (
 135   IN  OPAL_DRIVER_DEVICE         *Dev,
 136   OUT BOOLEAN                    *PressEsc
 137   )
 138 {
 139   EFI_INPUT_KEY                InputKey;
 140   UINTN                        InputLength;
 141   CHAR16                       Mask[MAX_PASSWORD_SIZE + 1];
 142   CHAR16                       Unicode[MAX_PASSWORD_SIZE + 1];
 143   CHAR8                        *Ascii;
 144   CHAR16                       *PopUpString;
 145   UINTN                        StrLength;
 146
 147   ZeroMem(Unicode, sizeof(Unicode));
 148   ZeroMem(Mask, sizeof(Mask));
 149
 150   StrLength = StrLen(Dev->Name16);
 151   PopUpString = (CHAR16*) AllocateZeroPool ((8 + StrLength) * 2);
 152   *PressEsc = FALSE;
 153
 154   if (Dev->Name16 == NULL) {
 155     UnicodeSPrint(PopUpString, StrLen(L"Unlock Disk") + 1, L"Unlock Disk");
 156   } else {
 157     UnicodeSPrint(PopUpString, StrLen(L"Unlock ") + StrLength + 1, L"Unlock %s", Dev->Name16);
 158   }
 159
 160   gST->ConOut->ClearScreen(gST->ConOut);
 161
 162   InputLength = 0;
 163   while (TRUE) {
 164     Mask[InputLength] = L'_';
 165     CreatePopUp(
 166         EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 167         &InputKey,
 168         PopUpString,
 169         L"---------------------",
 170         Mask,
 171         NULL
 172     );
 173
 174     //
 175     // Check key.
 176     //
 177     if (InputKey.ScanCode == SCAN_NULL) {
 178       //
 179       // password finished
 180       //
 181       if (InputKey.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 182         //
 183         // Add the null terminator.
 184         //
 185         Unicode[InputLength] = 0;
 186         InputLength++;
 187         break;
 188       } else if ((InputKey.UnicodeChar == CHAR_NULL) ||
 189                  (InputKey.UnicodeChar == CHAR_TAB) ||
 190                  (InputKey.UnicodeChar == CHAR_LINEFEED)
 191                 ) {
 192         continue;
 193       } else {
 194         //
 195         // delete last key entered
 196         //
 197         if (InputKey.UnicodeChar == CHAR_BACKSPACE) {
 198           if (InputLength > 0) {
 199             Unicode[InputLength] = 0;
 200             Mask[InputLength] = 0;
 201             InputLength--;
 202           }
 203         } else {
 204           //
 205           // add Next key entry
 206           //
 207           Unicode[InputLength] = InputKey.UnicodeChar;
 208           Mask[InputLength] = L'*';
 209           InputLength++;
 210           if (InputLength == MAX_PASSWORD_SIZE) {
 211             //
 212             // Add the null terminator.
 213             //
 214             Unicode[InputLength] = 0;
 215             Mask[InputLength] = 0;
 216             break;
 217           }
 218         }
 219       }
 220     }
 221
 222     //
 223     // exit on ESC
 224     //
 225     if (InputKey.ScanCode == SCAN_ESC) {
 226       *PressEsc = TRUE;
 227       break;
 228     }
 229   }
 230
 231   gST->ConOut->ClearScreen(gST->ConOut);
 232
 233   if (InputLength == 0 || InputKey.ScanCode == SCAN_ESC) {
 234     return NULL;
 235   }
 236
 237   Ascii = AllocateZeroPool (MAX_PASSWORD_SIZE + 1);
 238   if (Ascii == NULL) {
 239     return NULL;
 240   }
 241
 242   UnicodeStrToAsciiStrS (Unicode, Ascii, MAX_PASSWORD_SIZE + 1);
 243   ZeroMem (Unicode, sizeof (Unicode));
 244
 245   return Ascii;
 246 }
 247
 248 /**
 249   Check if disk is locked, show popup window and ask for password if it is
 250
 251   @param[in]       Dev          The device which need to be unlock.
 252
 253 **/
 254 VOID
 255 OpalDriverRequestPassword (
 256   OPAL_DRIVER_DEVICE       *Dev
 257   )
 258 {
 259   UINT8               Count;
 260   BOOLEAN             IsEnabled;
 261   CHAR8               *Password;
 262   UINT32              PasswordLen;
 263   TCG_RESULT          Ret;
 264   EFI_INPUT_KEY       Key;
 265   OPAL_SESSION        Session;
 266   BOOLEAN             PressEsc;
 267   BOOLEAN             Locked;
 268
 269   if (Dev == NULL) {
 270     return;
 271   }
 272
 273   Count = 0;
 274
 275   IsEnabled = OpalFeatureEnabled (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature);
 276   if (IsEnabled) {
 277     ZeroMem(&Session, sizeof(Session));
 278     Session.Sscp = Dev->OpalDisk.Sscp;
 279     Session.MediaId = Dev->OpalDisk.MediaId;
 280     Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;
 281
 282     Locked = OpalDeviceLocked (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature);
 283
 284     while (Count < MAX_PASSWORD_TRY_COUNT) {
 285       Password = OpalDriverPopUpHddPassword (Dev, &PressEsc);
 286       if (PressEsc) {
 287         if (Locked) {
 288           //
 289           // Current device in the lock status and
 290           // User not input password and press ESC,
 291           // keep device in lock status and continue boot.
 292           //
 293           do {
 294             CreatePopUp (
 295                     EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 296                     &Key,
 297                     L"Press ENTER to skip password, Press ESC to input password",
 298                     NULL
 299                     );
 300           } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 301
 302           if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 303             gST->ConOut->ClearScreen(gST->ConOut);
 304             //
 305             // Keep lock and continue boot.
 306             //
 307             return;
 308           } else {
 309             //
 310             // Let user input password again.
 311             //
 312             continue;
 313           }
 314         } else {
 315           //
 316           // Current device in the unlock status and
 317           // User not input password and press ESC,
 318           // Shutdown the device.
 319           //
 320           do {
 321             CreatePopUp (
 322                     EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 323                     &Key,
 324                     L"Press ENTER to shutdown, Press ESC to input password",
 325                     NULL
 326                     );
 327           } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 328
 329           if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 330             gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);
 331           } else {
 332             //
 333             // Let user input password again.
 334             //
 335             continue;
 336           }
 337         }
 338       }
 339
 340       if (Password == NULL) {
 341         Count ++;
 342         continue;
 343       }
 344       PasswordLen = (UINT32) AsciiStrLen(Password);
 345
 346       if (Locked) {
 347         Ret = OpalSupportUnlock(&Session, Password, PasswordLen, Dev->OpalDevicePath);
 348       } else {
 349         Ret = OpalSupportLock(&Session, Password, PasswordLen, Dev->OpalDevicePath);
 350         if (Ret == TcgResultSuccess) {
 351           Ret = OpalSupportUnlock(&Session, Password, PasswordLen, Dev->OpalDevicePath);
 352         }
 353       }
 354
 355       if (Password != NULL) {
 356         ZeroMem (Password, PasswordLen);
 357         FreePool (Password);
 358       }
 359
 360       if (Ret == TcgResultSuccess) {
 361         break;
 362       }
 363
 364       Count++;
 365
 366       do {
 367         CreatePopUp (
 368                   EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 369                   &Key,
 370                   L"Invalid password.",
 371                   L"Press ENTER to retry",
 372                   NULL
 373                   );
 374       } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
 375     }
 376
 377     if (Count >= MAX_PASSWORD_TRY_COUNT) {
 378       do {
 379         CreatePopUp (
 380                 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 381                 &Key,
 382                 L"Opal password retry count exceeds the limit. Must shutdown!",
 383                 L"Press ENTER to shutdown",
 384                 NULL
 385                 );
 386       } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
 387
 388       gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);
 389     }
 390   }
 391 }
 392
 393 /**
 394   Get devcie list info.
 395
 396   @retval     return the device list pointer.
 397 **/
 398 OPAL_DRIVER_DEVICE*
 399 OpalDriverGetDeviceList(
 400   VOID
 401   )
 402 {
 403   return mOpalDriver.DeviceList;
 404 }
 405
 406 /**
 407   ReadyToBoot callback to send BlockSid command.
 408
 409   @param  Event   Pointer to this event
 410   @param  Context Event handler private Data
 411
 412 **/
 413 VOID
 414 EFIAPI
 415 ReadyToBootCallback (
 416   IN EFI_EVENT        Event,
 417   IN VOID             *Context
 418   )
 419 {
 420   OPAL_DRIVER_DEVICE                         *Itr;
 421   TCG_RESULT                                 Result;
 422   OPAL_SESSION                               Session;
 423   UINT32                                     PpStorageFlag;
 424
 425   gBS->CloseEvent (Event);
 426
 427   PpStorageFlag = Tcg2PhysicalPresenceLibGetManagementFlags ();
 428   if ((PpStorageFlag & TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID) != 0) {
 429     //
 430     // Send BlockSID command to each Opal disk
 431     //
 432     Itr = mOpalDriver.DeviceList;
 433     while (Itr != NULL) {
 434       if (Itr->OpalDisk.SupportedAttributes.BlockSid) {
 435         ZeroMem(&Session, sizeof(Session));
 436         Session.Sscp = Itr->OpalDisk.Sscp;
 437         Session.MediaId = Itr->OpalDisk.MediaId;
 438         Session.OpalBaseComId = Itr->OpalDisk.OpalBaseComId;
 439
 440         Result = OpalBlockSid (&Session, TRUE);  // HardwareReset must always be TRUE
 441         if (Result != TcgResultSuccess) {
 442           DEBUG ((DEBUG_ERROR, "OpalBlockSid fail\n"));
 443           break;
 444         }
 445       }
 446
 447       Itr = Itr->Next;
 448     }
 449   }
 450 }
 451
 452 /**
 453   Stop this Controller.
 454
 455   @param  Dev               The device need to be stopped.
 456
 457 **/
 458 VOID
 459 OpalDriverStopDevice (
 460   OPAL_DRIVER_DEVICE     *Dev
 461   )
 462 {
 463   //
 464   // free each name
 465   //
 466   FreePool(Dev->Name16);
 467
 468   //
 469   // remove OPAL_DRIVER_DEVICE from the list
 470   // it updates the controllerList pointer
 471   //
 472   RemoveDevice(Dev);
 473
 474   //
 475   // close protocols that were opened
 476   //
 477   gBS->CloseProtocol(
 478     Dev->Handle,
 479     &gEfiStorageSecurityCommandProtocolGuid,
 480     gOpalDriverBinding.DriverBindingHandle,
 481     Dev->Handle
 482     );
 483
 484   gBS->CloseProtocol(
 485     Dev->Handle,
 486     &gEfiBlockIoProtocolGuid,
 487     gOpalDriverBinding.DriverBindingHandle,
 488     Dev->Handle
 489     );
 490
 491   FreePool(Dev);
 492 }
 493
 494 /**
 495   Get devcie name through the component name protocol.
 496
 497   @param[in]       AllHandlesBuffer   The handle buffer for current system.
 498   @param[in]       NumAllHandles      The number of handles for the handle buffer.
 499   @param[in]       Dev                The device which need to get name.
 500   @param[in]       UseComp1           Whether use component name or name2 protocol.
 501
 502   @retval     TRUE        Find the name for this device.
 503   @retval     FALSE       Not found the name for this device.
 504 **/
 505 BOOLEAN
 506 OpalDriverGetDeviceNameByProtocol(
 507   EFI_HANDLE             *AllHandlesBuffer,
 508   UINTN                  NumAllHandles,
 509   OPAL_DRIVER_DEVICE     *Dev,
 510   BOOLEAN                UseComp1
 511   )
 512 {
 513   EFI_HANDLE*                   ProtocolHandlesBuffer;
 514   UINTN                         NumProtocolHandles;
 515   EFI_STATUS                    Status;
 516   EFI_COMPONENT_NAME2_PROTOCOL* Cnp1_2; // efi component name and componentName2 have same layout
 517   EFI_GUID                      Protocol;
 518   UINTN                         StrLength;
 519   EFI_DEVICE_PATH_PROTOCOL*     TmpDevPath;
 520   UINTN                         Index1;
 521   UINTN                         Index2;
 522   EFI_HANDLE                    TmpHandle;
 523   CHAR16                        *DevName;
 524
 525   if (Dev == NULL || AllHandlesBuffer == NULL || NumAllHandles == 0) {
 526     return FALSE;
 527   }
 528
 529   Protocol = UseComp1 ? gEfiComponentNameProtocolGuid : gEfiComponentName2ProtocolGuid;
 530
 531   //
 532   // Find all EFI_HANDLES with protocol
 533   //
 534   Status = gBS->LocateHandleBuffer(
 535                ByProtocol,
 536                &Protocol,
 537                NULL,
 538                &NumProtocolHandles,
 539                &ProtocolHandlesBuffer
 540                );
 541   if (EFI_ERROR(Status)) {
 542     return FALSE;
 543   }
 544
 545
 546   //
 547   // Exit early if no supported devices
 548   //
 549   if (NumProtocolHandles == 0) {
 550     return FALSE;
 551   }
 552
 553   //
 554   // Get printable name by iterating through all protocols
 555   // using the handle as the child, and iterate through all handles for the controller
 556   // exit loop early once found, if not found, then delete device
 557   // storage security protocol instances already exist, add them to internal list
 558   //
 559   Status = EFI_DEVICE_ERROR;
 560   for (Index1 = 0; Index1 < NumProtocolHandles; Index1++) {
 561     DevName = NULL;
 562
 563     if (Dev->Name16 != NULL) {
 564       return TRUE;
 565     }
 566
 567     TmpHandle = ProtocolHandlesBuffer[Index1];
 568
 569     Status = gBS->OpenProtocol(
 570                  TmpHandle,
 571                  &Protocol,
 572                  (VOID**)&Cnp1_2,
 573                  gImageHandle,
 574                  NULL,
 575                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
 576                  );
 577     if (EFI_ERROR(Status) || Cnp1_2 == NULL) {
 578       continue;
 579     }
 580
 581     //
 582     // Use all handles array as controller handle
 583     //
 584     for (Index2 = 0; Index2 < NumAllHandles; Index2++) {
 585       Status = Cnp1_2->GetControllerName(
 586                    Cnp1_2,
 587                    AllHandlesBuffer[Index2],
 588                    Dev->Handle,
 589                    LANGUAGE_ISO_639_2_ENGLISH,
 590                    &DevName
 591                    );
 592       if (EFI_ERROR(Status)) {
 593         Status = Cnp1_2->GetControllerName(
 594                      Cnp1_2,
 595                      AllHandlesBuffer[Index2],
 596                      Dev->Handle,
 597                      LANGUAGE_RFC_3066_ENGLISH,
 598                      &DevName
 599                      );
 600       }
 601       if (!EFI_ERROR(Status) && DevName != NULL) {
 602         StrLength = StrLen(DevName) + 1;        // Add one for NULL terminator
 603         Dev->Name16 = AllocateZeroPool(StrLength * sizeof (CHAR16));
 604         ASSERT (Dev->Name16 != NULL);
 605         StrCpyS (Dev->Name16, StrLength, DevName);
 606         Dev->NameZ = (CHAR8*)AllocateZeroPool(StrLength);
 607         UnicodeStrToAsciiStrS (DevName, Dev->NameZ, StrLength);
 608
 609         //
 610         // Retrieve bridge BDF info and port number or namespace depending on type
 611         //
 612         TmpDevPath = NULL;
 613         Status = gBS->OpenProtocol(
 614             Dev->Handle,
 615             &gEfiDevicePathProtocolGuid,
 616             (VOID**)&TmpDevPath,
 617             gImageHandle,
 618             NULL,
 619             EFI_OPEN_PROTOCOL_GET_PROTOCOL
 620             );
 621         if (!EFI_ERROR(Status)) {
 622           Dev->OpalDevicePath = DuplicateDevicePath (TmpDevPath);
 623           return TRUE;
 624         }
 625
 626         if (Dev->Name16 != NULL) {
 627           FreePool(Dev->Name16);
 628           Dev->Name16 = NULL;
 629         }
 630         if (Dev->NameZ != NULL) {
 631           FreePool(Dev->NameZ);
 632           Dev->NameZ = NULL;
 633         }
 634       }
 635     }
 636   }
 637
 638   return FALSE;
 639 }
 640
 641 /**
 642   Get devcie name through the component name protocol.
 643
 644   @param[in]       Dev                The device which need to get name.
 645
 646   @retval     TRUE        Find the name for this device.
 647   @retval     FALSE       Not found the name for this device.
 648 **/
 649 BOOLEAN
 650 OpalDriverGetDriverDeviceName(
 651   OPAL_DRIVER_DEVICE          *Dev
 652   )
 653 {
 654   EFI_HANDLE*                  AllHandlesBuffer;
 655   UINTN                        NumAllHandles;
 656   EFI_STATUS                   Status;
 657
 658   if (Dev == NULL) {
 659     DEBUG((DEBUG_ERROR | DEBUG_INIT, "OpalDriverGetDriverDeviceName Exiting, Dev=NULL\n"));
 660     return FALSE;
 661   }
 662
 663   //
 664   // Iterate through ComponentName2 handles to get name, if fails, try ComponentName
 665   //
 666   if (Dev->Name16 == NULL) {
 667     DEBUG((DEBUG_ERROR | DEBUG_INIT, "Name is null, update it\n"));
 668     //
 669     // Find all EFI_HANDLES
 670     //
 671     Status = gBS->LocateHandleBuffer(
 672                  AllHandles,
 673                  NULL,
 674                  NULL,
 675                  &NumAllHandles,
 676                  &AllHandlesBuffer
 677                  );
 678     if (EFI_ERROR(Status)) {
 679       DEBUG ((DEBUG_INFO, "LocateHandleBuffer for AllHandles failed %r\n", Status ));
 680       return FALSE;
 681     }
 682
 683     //
 684     // Try component Name2
 685     //
 686     if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, FALSE)) {
 687       DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName2 failed to get device name, try ComponentName\n"));
 688       if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, TRUE)) {
 689         DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName failed to get device name, skip device\n"));
 690         return FALSE;
 691       }
 692     }
 693   }
 694
 695   return TRUE;
 696 }
 697
 698 /**
 699   Main entry for this driver.
 700
 701   @param ImageHandle     Image Handle this driver.
 702   @param SystemTable     Pointer to SystemTable.
 703
 704   @retval EFI_SUCESS     This function always complete successfully.
 705 **/
 706 EFI_STATUS
 707 EFIAPI
 708 EfiDriverEntryPoint(
 709   IN EFI_HANDLE         ImageHandle,
 710   IN EFI_SYSTEM_TABLE*  SystemTable
 711   )
 712 {
 713   EFI_STATUS                     Status;
 714   EFI_EVENT                      ReadyToBootEvent;
 715
 716   Status = EfiLibInstallDriverBindingComponentName2 (
 717              ImageHandle,
 718              SystemTable,
 719              &gOpalDriverBinding,
 720              ImageHandle,
 721              &gOpalComponentName,
 722              &gOpalComponentName2
 723              );
 724
 725   if (EFI_ERROR(Status)) {
 726     DEBUG((DEBUG_ERROR, "Install protocols to Opal driver Handle failed\n"));
 727     return Status ;
 728   }
 729
 730   //
 731   // Initialize Driver object
 732   //
 733   ZeroMem(&mOpalDriver, sizeof(mOpalDriver));
 734   mOpalDriver.Handle = ImageHandle;
 735
 736   //
 737   // register a ReadyToBoot event callback for sending BlockSid command
 738   //
 739   Status = EfiCreateEventReadyToBootEx (
 740                   TPL_CALLBACK,
 741                   ReadyToBootCallback,
 742                   (VOID *) &ImageHandle,
 743                   &ReadyToBootEvent
 744                   );
 745
 746   //
 747   // Install Hii packages.
 748   //
 749   HiiInstall();
 750
 751   return Status;
 752 }
 753
 754 /**
 755   Tests to see if this driver supports a given controller.
 756
 757   This function checks to see if the controller contains an instance of the
 758   EFI_STORAGE_SECURITY_COMMAND_PROTOCOL and the EFI_BLOCK_IO_PROTOCL
 759   and returns EFI_SUCCESS if it does.
 760
 761   @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 762   @param[in]  ControllerHandle      The Handle of the controller to test. This Handle
 763                                     must support a protocol interface that supplies
 764                                     an I/O abstraction to the driver.
 765   @param[in]  RemainingDevicePath  This parameter is ignored.
 766
 767   @retval EFI_SUCCESS               The device contains required protocols
 768   @retval EFI_ALREADY_STARTED       The device specified by ControllerHandle and
 769                                     RemainingDevicePath is already being managed by the driver
 770                                     specified by This.
 771   @retval EFI_ACCESS_DENIED         The device specified by ControllerHandle and
 772                                     RemainingDevicePath is already being managed by a different
 773                                     driver or an application that requires exclusive access.
 774                                     Currently not implemented.
 775   @retval EFI_UNSUPPORTED           The device does not contain requires protocols
 776
 777 **/
 778 EFI_STATUS
 779 EFIAPI
 780 OpalEfiDriverBindingSupported(
 781   IN EFI_DRIVER_BINDING_PROTOCOL* This,
 782   IN EFI_HANDLE                   Controller,
 783   IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath
 784   )
 785 {
 786   EFI_STATUS                              Status;
 787   EFI_STORAGE_SECURITY_COMMAND_PROTOCOL*  SecurityCommand;
 788   EFI_BLOCK_IO_PROTOCOL*                  BlkIo;
 789
 790   //
 791   // Test EFI_STORAGE_SECURITY_COMMAND_PROTOCOL on controller Handle.
 792   //
 793   Status = gBS->OpenProtocol(
 794     Controller,
 795     &gEfiStorageSecurityCommandProtocolGuid,
 796     ( VOID ** )&SecurityCommand,
 797     This->DriverBindingHandle,
 798     Controller,
 799     EFI_OPEN_PROTOCOL_BY_DRIVER
 800     );
 801
 802   if (Status == EFI_ALREADY_STARTED) {
 803     return EFI_SUCCESS;
 804   }
 805
 806   if (EFI_ERROR(Status)) {
 807     return Status;
 808   }
 809
 810   //
 811   // Close protocol and reopen in Start call
 812   //
 813   gBS->CloseProtocol(
 814       Controller,
 815       &gEfiStorageSecurityCommandProtocolGuid,
 816       This->DriverBindingHandle,
 817       Controller
 818       );
 819
 820   //
 821   // Test EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
 822   // function APIs
 823   //
 824   Status = gBS->OpenProtocol(
 825     Controller,
 826     &gEfiBlockIoProtocolGuid,
 827     (VOID **)&BlkIo,
 828     This->DriverBindingHandle,
 829     Controller,
 830     EFI_OPEN_PROTOCOL_BY_DRIVER
 831     );
 832
 833   if (EFI_ERROR(Status)) {
 834     DEBUG((DEBUG_INFO, "No EFI_BLOCK_IO_PROTOCOL on controller\n"));
 835     return Status;
 836   }
 837
 838   //
 839   // Close protocol and reopen in Start call
 840   //
 841   gBS->CloseProtocol(
 842     Controller,
 843     &gEfiBlockIoProtocolGuid,
 844     This->DriverBindingHandle,
 845     Controller
 846     );
 847
 848   return EFI_SUCCESS;
 849 }
 850
 851 /**
 852   Enables Opal Management on a supported device if available.
 853
 854   The start function is designed to be called after the Opal UEFI Driver has confirmed the
 855   "controller", which is a child Handle, contains the EF_STORAGE_SECURITY_COMMAND protocols.
 856   This function will complete the other necessary checks, such as verifying the device supports
 857   the correct version of Opal.  Upon verification, it will add the device to the
 858   Opal HII list in order to expose Opal managmeent options.
 859
 860   @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 861   @param[in]  ControllerHandle      The Handle of the controller to start. This Handle
 862                                     must support a protocol interface that supplies
 863                                     an I/O abstraction to the driver.
 864   @param[in]  RemainingDevicePath   A pointer to the remaining portion of a device path.  This
 865                                     parameter is ignored by device drivers, and is optional for bus
 866                                     drivers. For a bus driver, if this parameter is NULL, then handles
 867                                     for all the children of Controller are created by this driver.
 868                                     If this parameter is not NULL and the first Device Path Node is
 869                                     not the End of Device Path Node, then only the Handle for the
 870                                     child device specified by the first Device Path Node of
 871                                     RemainingDevicePath is created by this driver.
 872                                     If the first Device Path Node of RemainingDevicePath is
 873                                     the End of Device Path Node, no child Handle is created by this
 874                                     driver.
 875
 876   @retval EFI_SUCCESS               Opal management was enabled.
 877   @retval EFI_DEVICE_ERROR          The device could not be started due to a device error.Currently not implemented.
 878   @retval EFI_OUT_OF_RESOURCES      The request could not be completed due to a lack of resources.
 879   @retval Others                    The driver failed to start the device.
 880
 881 **/
 882 EFI_STATUS
 883 EFIAPI
 884 OpalEfiDriverBindingStart(
 885   IN EFI_DRIVER_BINDING_PROTOCOL* This,
 886   IN EFI_HANDLE                   Controller,
 887   IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath
 888   )
 889 {
 890   EFI_STATUS                  Status;
 891   EFI_BLOCK_IO_PROTOCOL       *BlkIo;
 892   OPAL_DRIVER_DEVICE          *Dev;
 893   OPAL_DRIVER_DEVICE          *Itr;
 894   BOOLEAN                     Result;
 895
 896   Itr = mOpalDriver.DeviceList;
 897   while (Itr != NULL) {
 898     if (Controller == Itr->Handle) {
 899       return EFI_SUCCESS;
 900     }
 901     Itr = Itr->Next;
 902   }
 903
 904   //
 905   // Create internal device for tracking.  This allows all disks to be tracked
 906   // by same HII form
 907   //
 908   Dev = (OPAL_DRIVER_DEVICE*)AllocateZeroPool(sizeof(OPAL_DRIVER_DEVICE));
 909   if (Dev == NULL) {
 910     return EFI_OUT_OF_RESOURCES;
 911   }
 912   Dev->Handle = Controller;
 913
 914   //
 915   // Open EFI_STORAGE_SECURITY_COMMAND_PROTOCOL to perform Opal supported checks
 916   //
 917   Status = gBS->OpenProtocol(
 918     Controller,
 919     &gEfiStorageSecurityCommandProtocolGuid,
 920     (VOID **)&Dev->Sscp,
 921     This->DriverBindingHandle,
 922     Controller,
 923     EFI_OPEN_PROTOCOL_BY_DRIVER
 924     );
 925   if (EFI_ERROR(Status)) {
 926     FreePool(Dev);
 927     return Status;
 928   }
 929
 930   //
 931   // Open EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
 932   // function APIs
 933   //
 934   Status = gBS->OpenProtocol(
 935     Controller,
 936     &gEfiBlockIoProtocolGuid,
 937     (VOID **)&BlkIo,
 938     This->DriverBindingHandle,
 939     Controller,
 940     EFI_OPEN_PROTOCOL_BY_DRIVER
 941     );
 942   if (EFI_ERROR(Status)) {
 943     //
 944     // Close storage security that was opened
 945     //
 946     gBS->CloseProtocol(
 947         Controller,
 948         &gEfiStorageSecurityCommandProtocolGuid,
 949         This->DriverBindingHandle,
 950         Controller
 951         );
 952
 953     FreePool(Dev);
 954     return Status;
 955   }
 956
 957   //
 958   // Save mediaId
 959   //
 960   Dev->MediaId = BlkIo->Media->MediaId;
 961
 962   gBS->CloseProtocol(
 963     Controller,
 964     &gEfiBlockIoProtocolGuid,
 965     This->DriverBindingHandle,
 966     Controller
 967     );
 968
 969   //
 970   // Acquire Ascii printable name of child, if not found, then ignore device
 971   //
 972   Result = OpalDriverGetDriverDeviceName (Dev);
 973   if (!Result) {
 974     goto Done;
 975   }
 976
 977   Status = OpalDiskInitialize (Dev);
 978   if (EFI_ERROR (Status)) {
 979     goto Done;
 980   }
 981
 982   AddDeviceToTail(Dev);
 983
 984   //
 985   // check if device is locked and prompt for password
 986   //
 987   OpalDriverRequestPassword (Dev);
 988
 989   return EFI_SUCCESS;
 990
 991 Done:
 992   //
 993   // free device, close protocols and exit
 994   //
 995   gBS->CloseProtocol(
 996       Controller,
 997       &gEfiStorageSecurityCommandProtocolGuid,
 998       This->DriverBindingHandle,
 999       Controller
1000       );
1001
1002   FreePool(Dev);
1003
1004   return EFI_DEVICE_ERROR;
1005 }
1006
1007 /**
1008   Stop this driver on Controller.
1009
1010   @param  This              Protocol instance pointer.
1011   @param  Controller        Handle of device to stop driver on
1012   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1013                             children is zero stop the entire bus driver.
1014   @param  ChildHandleBuffer List of Child Handles to Stop.
1015
1016   @retval EFI_SUCCESS       This driver is removed Controller.
1017   @retval other             This driver could not be removed from this device.
1018
1019 **/
1020 EFI_STATUS
1021 EFIAPI
1022 OpalEfiDriverBindingStop(
1023   EFI_DRIVER_BINDING_PROTOCOL*    This,
1024   EFI_HANDLE                      Controller,
1025   UINTN                           NumberOfChildren,
1026   EFI_HANDLE*                     ChildHandleBuffer
1027   )
1028 {
1029   OPAL_DRIVER_DEVICE*   Itr;
1030
1031   Itr = mOpalDriver.DeviceList;
1032
1033   //
1034   // does Controller match any of the devices we are managing for Opal
1035   //
1036   while (Itr != NULL) {
1037     if (Itr->Handle == Controller) {
1038       OpalDriverStopDevice (Itr);
1039       return EFI_SUCCESS;
1040     }
1041
1042     Itr = Itr->Next;
1043   }
1044
1045   return EFI_NOT_FOUND;
1046 }
1047
1048
1049 /**
1050   Unloads UEFI Driver.  Very useful for debugging and testing.
1051
1052   @param ImageHandle            Image Handle this driver.
1053
1054   @retval EFI_SUCCESS           This function always complete successfully.
1055   @retval EFI_INVALID_PARAMETER The input ImageHandle is not valid.
1056 **/
1057 EFI_STATUS
1058 EFIAPI
1059 OpalEfiDriverUnload (
1060   IN EFI_HANDLE ImageHandle
1061   )
1062 {
1063   EFI_STATUS                     Status;
1064   OPAL_DRIVER_DEVICE                   *Itr;
1065
1066   Status = EFI_SUCCESS;
1067
1068   if (ImageHandle != gImageHandle) {
1069     return (EFI_INVALID_PARAMETER);
1070   }
1071
1072   //
1073   // Uninstall any interface added to each device by us
1074   //
1075   while (mOpalDriver.DeviceList) {
1076     Itr = mOpalDriver.DeviceList;
1077     //
1078     // Remove OPAL_DRIVER_DEVICE from the list
1079     // it updates the controllerList pointer
1080     //
1081     OpalDriverStopDevice(Itr);
1082   }
1083
1084   //
1085   // Uninstall the HII capability
1086   //
1087   Status = HiiUninstall();
1088
1089   return Status;
1090 }
1091