EdkUnixPkg/Dxe/PlatformBds/Generic/DeviceMngr/DeviceManager.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   DeviceManager.c
  15
  16 Abstract:
  17
  18   The platform device manager reference implement
  19
  20 --*/
  21 #include "DeviceManager.h"
  22
  23 STATIC UINT16                     mTokenCount;
  24 EFI_FRONTPAGE_CALLBACK_INFO       FPCallbackInfo;
  25 extern UINTN                      gCallbackKey;
  26 extern EFI_FORM_BROWSER_PROTOCOL  *gBrowser;
  27 extern EFI_GUID                   gBdsStringPackGuid;
  28 extern BOOLEAN                    gConnectAllHappened;
  29
  30 STRING_REF                        gStringTokenTable[] = {
  31   STR_VIDEO_DEVICE,
  32   STR_NETWORK_DEVICE,
  33   STR_INPUT_DEVICE,
  34   STR_ON_BOARD_DEVICE,
  35   STR_OTHER_DEVICE,
  36   STR_EMPTY_STRING,
  37   0xFFFF
  38 };
  39
  40 EFI_STATUS
  41 EFIAPI
  42 DeviceManagerCallbackRoutine (
  43   IN EFI_FORM_CALLBACK_PROTOCOL       *This,
  44   IN UINT16                           KeyValue,
  45   IN EFI_IFR_DATA_ARRAY               *DataArray,
  46   OUT EFI_HII_CALLBACK_PACKET         **Packet
  47   )
  48 /*++
  49
  50 Routine Description:
  51
  52   This is the function that is called to provide results data to the driver.  This data
  53   consists of a unique key which is used to identify what data is either being passed back
  54   or being asked for.
  55
  56 Arguments:
  57
  58   KeyValue -        A unique value which is sent to the original exporting driver so that it
  59                     can identify the type of data to expect.  The format of the data tends to
  60                     vary based on the op-code that geerated the callback.
  61
  62   Data -            A pointer to the data being sent to the original exporting driver.
  63
  64 Returns:
  65
  66 --*/
  67 {
  68   //
  69   // The KeyValue corresponds in this case to the handle which was requested to be displayed
  70   //
  71   EFI_FRONTPAGE_CALLBACK_INFO *CallbackInfo;
  72
  73   CallbackInfo = EFI_FP_CALLBACK_DATA_FROM_THIS (This);
  74   switch (KeyValue) {
  75   case 0x2000:
  76     CallbackInfo->Data.VideoBIOS = (UINT8) (UINTN) (((EFI_IFR_DATA_ENTRY *)(DataArray + 1))->Data);
  77     gRT->SetVariable (
  78           L"VBIOS",
  79           &gEfiGlobalVariableGuid,
  80           EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
  81           sizeof (UINT8),
  82           &CallbackInfo->Data.VideoBIOS
  83           );
  84     break;
  85
  86   default:
  87     break;
  88   }
  89
  90   gCallbackKey = KeyValue;
  91   return EFI_SUCCESS;
  92 }
  93
  94 EFI_STATUS
  95 InitializeDeviceManager (
  96   VOID
  97   )
  98 /*++
  99
 100 Routine Description:
 101
 102   Initialize HII information for the FrontPage
 103
 104 Arguments:
 105   None
 106
 107 Returns:
 108
 109 --*/
 110 {
 111   EFI_STATUS          Status;
 112   EFI_HII_PACKAGES    *PackageList;
 113   EFI_HII_UPDATE_DATA *UpdateData;
 114
 115   //
 116   // Allocate space for creation of UpdateData Buffer
 117   //
 118   UpdateData = AllocateZeroPool (0x1000);
 119   ASSERT (UpdateData != NULL);
 120
 121   PackageList = PreparePackages (1, &gBdsStringPackGuid, DeviceManagerVfrBin);
 122   Status      = Hii->NewPack (Hii, PackageList, &FPCallbackInfo.DevMgrHiiHandle);
 123   gBS->FreePool (PackageList);
 124
 125   //
 126   // This example does not implement worker functions for the NV accessor functions.  Only a callback evaluator
 127   //
 128   FPCallbackInfo.Signature                = EFI_FP_CALLBACK_DATA_SIGNATURE;
 129   FPCallbackInfo.DevMgrCallback.NvRead    = NULL;
 130   FPCallbackInfo.DevMgrCallback.NvWrite   = NULL;
 131   FPCallbackInfo.DevMgrCallback.Callback  = DeviceManagerCallbackRoutine;
 132
 133   //
 134   // Install protocol interface
 135   //
 136   FPCallbackInfo.CallbackHandle = NULL;
 137
 138   Status = gBS->InstallProtocolInterface (
 139                   &FPCallbackInfo.CallbackHandle,
 140                   &gEfiFormCallbackProtocolGuid,
 141                   EFI_NATIVE_INTERFACE,
 142                   &FPCallbackInfo.DevMgrCallback
 143                   );
 144
 145   ASSERT_EFI_ERROR (Status);
 146
 147   //
 148   // Flag update pending in FormSet
 149   //
 150   UpdateData->FormSetUpdate = TRUE;
 151   //
 152   // Register CallbackHandle data for FormSet
 153   //
 154   UpdateData->FormCallbackHandle = (EFI_PHYSICAL_ADDRESS) (UINTN) FPCallbackInfo.CallbackHandle;
 155   //
 156   // Simply registering the callback handle
 157   //
 158   Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) 0x0000, TRUE, UpdateData);
 159
 160   gBS->FreePool (UpdateData);
 161   return Status;
 162 }
 163
 164 EFI_STATUS
 165 CallDeviceManager (
 166   VOID
 167   )
 168 /*++
 169
 170 Routine Description:
 171
 172   Call the browser and display the device manager
 173
 174 Arguments:
 175
 176   None
 177
 178 Returns:
 179   EFI_SUCCESS            - Operation is successful.
 180   EFI_INVALID_PARAMETER  - If the inputs to SendForm function is not valid.
 181
 182 --*/
 183 {
 184   EFI_STATUS          Status;
 185   UINTN               BufferSize;
 186   UINTN               Count;
 187   EFI_HII_HANDLE      Index;
 188   UINT8               *Buffer;
 189   EFI_IFR_FORM_SET    *FormSetData;
 190   CHAR16              *String;
 191   UINTN               StringLength;
 192   EFI_HII_UPDATE_DATA *UpdateData;
 193   STRING_REF          Token;
 194   STRING_REF          TokenHelp;
 195   IFR_OPTION          *IfrOptionList;
 196   UINT8               *VideoOption;
 197   UINTN               VideoOptionSize;
 198   EFI_HII_HANDLE      *HiiHandles;
 199   UINT16              HandleBufferLength;
 200   BOOLEAN                 BootDeviceMngrMenuResetRequired;
 201
 202   IfrOptionList       = NULL;
 203   VideoOption         = NULL;
 204   HandleBufferLength  = 0;
 205
 206   //
 207   // Connect all prior to entering the platform setup menu.
 208   //
 209   if (!gConnectAllHappened) {
 210     BdsLibConnectAllDriversToAllControllers ();
 211     gConnectAllHappened = TRUE;
 212   }
 213   //
 214   // Allocate space for creation of UpdateData Buffer
 215   //
 216   UpdateData = AllocateZeroPool (0x1000);
 217   ASSERT (UpdateData != NULL);
 218
 219   Status        = EFI_SUCCESS;
 220   Buffer        = NULL;
 221   FormSetData   = NULL;
 222   gCallbackKey  = 0;
 223   if (mTokenCount == 0) {
 224     Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &mTokenCount, L" ");
 225   }
 226
 227   Token     = mTokenCount;
 228   TokenHelp = (UINT16) (Token + 1);
 229
 230   //
 231   // Reset the menu
 232   //
 233   for (Index = 0, Count = 1; Count < 0x10000; Count <<= 1, Index++) {
 234     //
 235     // We will strip off all previous menu entries
 236     //
 237     UpdateData->DataCount = 0xFF;
 238
 239     //
 240     // Erase entries on this label
 241     //
 242     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, FALSE, UpdateData);
 243
 244     //
 245     // Did we reach the end of the Token Table?
 246     //
 247     if (gStringTokenTable[Index] == 0xFFFF) {
 248       break;
 249     }
 250
 251     CreateSubTitleOpCode (gStringTokenTable[Index], &UpdateData->Data);
 252     //
 253     // Add a single menu item - in this case a subtitle for the device type
 254     //
 255     UpdateData->DataCount = 1;
 256
 257     //
 258     // Add default title for this label
 259     //
 260     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 261   }
 262   //
 263   // Add a space and an exit string.  Remember since we add things at the label and push other things beyond the
 264   // label down, we add this in reverse order
 265   //
 266   CreateSubTitleOpCode (STRING_TOKEN (STR_EXIT_STRING), &UpdateData->Data);
 267   Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 268   CreateSubTitleOpCode (STR_EMPTY_STRING, &UpdateData->Data);
 269   Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 270
 271   HiiHandles = AllocateZeroPool (HandleBufferLength);
 272   Hii->FindHandles (Hii, &HandleBufferLength, HiiHandles);
 273
 274   for (Index = 1, BufferSize = 0; Index < HandleBufferLength; Index++) {
 275     //
 276     // Am not initializing Buffer since the first thing checked is the size
 277     // this way I can get the real buffersize in the smallest code size
 278     //
 279     Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
 280
 281     if (Status != EFI_NOT_FOUND) {
 282       //
 283       // BufferSize should have the real size of the forms now
 284       //
 285       Buffer = AllocateZeroPool (BufferSize);
 286       ASSERT (Buffer != NULL);
 287
 288       //
 289       // Am not initializing Buffer since the first thing checked is the size
 290       // this way I can get the real buffersize in the smallest code size
 291       //
 292       Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
 293
 294       //
 295       // Skip EFI_HII_PACK_HEADER, advance to EFI_IFR_FORM_SET data.
 296       //
 297       FormSetData = (EFI_IFR_FORM_SET *) (Buffer + sizeof (EFI_HII_PACK_HEADER));
 298
 299       //
 300       // If this formset belongs in the device manager, add it to the menu
 301       //
 302       if (FormSetData->Class != EFI_NON_DEVICE_CLASS) {
 303
 304         StringLength  = 0x1000;
 305         String        = AllocateZeroPool (StringLength);
 306         ASSERT (String != NULL);
 307
 308         Status  = Hii->GetString (Hii, Index, FormSetData->FormSetTitle, TRUE, NULL, &StringLength, String);
 309         Status  = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
 310
 311         //
 312         // If token value exceeded real token value - we need to add a new token values
 313         //
 314         if (Status == EFI_INVALID_PARAMETER) {
 315           Token     = 0;
 316           TokenHelp = 0;
 317           Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
 318         }
 319
 320         StringLength = 0x1000;
 321         if (FormSetData->Help == 0) {
 322           TokenHelp = 0;
 323         } else {
 324           Status = Hii->GetString (Hii, Index, FormSetData->Help, TRUE, NULL, &StringLength, String);
 325           if (StringLength == 0x02) {
 326             TokenHelp = 0;
 327           } else {
 328             Status = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
 329             if (Status == EFI_INVALID_PARAMETER) {
 330               TokenHelp = 0;
 331               Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
 332             }
 333           }
 334         }
 335
 336         gBS->FreePool (String);
 337
 338         CreateGotoOpCode (
 339           0x1000,     // Device Manager Page
 340           Token,      // Description String Token
 341           TokenHelp,  // Description Help String Token
 342           EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,  // Flag designating callback is active
 343           (UINT16) Index,                                     // Callback key value
 344           &UpdateData->Data                                   // Buffer to fill with op-code
 345           );
 346
 347         //
 348         // In the off-chance that we have lots of extra tokens allocated to the DeviceManager
 349         // this ensures we are fairly re-using the tokens instead of constantly growing the token
 350         // storage for this one handle.  If we incremented the token value beyond what it normally
 351         // would use, we will fall back into the error path which seeds the token value with a 0
 352         // so that we can correctly add a token value.
 353         //
 354         if (TokenHelp == 0) {
 355           //
 356           // Since we didn't add help, only advance Token by 1
 357           //
 358           Token++;
 359         } else {
 360           Token     = (UINT16) (Token + 2);
 361           TokenHelp = (UINT16) (TokenHelp + 2);
 362         }
 363         //
 364         // This for loop basically will take the Class value which is a bitmask and
 365         // update the form for every active bit.  There will be a label at each bit
 366         // location.  So if someone had a device which a class of EFI_DISK_DEVICE_CLASS |
 367         // EFI_ON_BOARD_DEVICE_CLASS, this routine will unwind that mask and drop the menu entry
 368         // on each corresponding label.
 369         //
 370         for (Count = 1; Count < 0x10000; Count <<= 1) {
 371           //
 372           // This is an active bit, so update the form
 373           //
 374           if (FormSetData->Class & Count) {
 375             Hii->UpdateForm (
 376                   Hii,
 377                   FPCallbackInfo.DevMgrHiiHandle,
 378                   (EFI_FORM_LABEL) (FormSetData->Class & Count),
 379                   TRUE,
 380                   UpdateData
 381                   );
 382           }
 383         }
 384       }
 385
 386       BufferSize = 0;
 387       //
 388       // Reset Buffer pointer to original location
 389       //
 390       gBS->FreePool (Buffer);
 391     }
 392   }
 393   //
 394   // Add oneof for video BIOS selection
 395   //
 396   VideoOption = BdsLibGetVariableAndSize (
 397                   L"VBIOS",
 398                   &gEfiGlobalVariableGuid,
 399                   &VideoOptionSize
 400                   );
 401   if (NULL == VideoOption) {
 402     FPCallbackInfo.Data.VideoBIOS = 0;
 403   } else {
 404     FPCallbackInfo.Data.VideoBIOS = VideoOption[0];
 405     gBS->FreePool (VideoOption);
 406   }
 407
 408   ASSERT (FPCallbackInfo.Data.VideoBIOS <= 1);
 409
 410   Status = gBS->AllocatePool (EfiBootServicesData, 2 * sizeof (IFR_OPTION), &IfrOptionList);
 411   if (IfrOptionList != NULL) {
 412     IfrOptionList[0].Flags        = EFI_IFR_FLAG_INTERACTIVE;
 413     IfrOptionList[0].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
 414     IfrOptionList[0].StringToken  = STRING_TOKEN (STR_ONE_OF_PCI);
 415     IfrOptionList[0].Value        = 0;
 416     IfrOptionList[0].OptionString = NULL;
 417     IfrOptionList[1].Flags        = EFI_IFR_FLAG_INTERACTIVE;
 418     IfrOptionList[1].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
 419     IfrOptionList[1].StringToken  = STRING_TOKEN (STR_ONE_OF_AGP);
 420     IfrOptionList[1].Value        = 1;
 421     IfrOptionList[1].OptionString = NULL;
 422     IfrOptionList[FPCallbackInfo.Data.VideoBIOS].Flags |= EFI_IFR_FLAG_DEFAULT;
 423
 424     CreateOneOfOpCode (
 425       SET_VIDEO_BIOS_TYPE_QUESTION_ID,
 426       (UINT8) 1,
 427       STRING_TOKEN (STR_ONE_OF_VBIOS),
 428       STRING_TOKEN (STR_ONE_OF_VBIOS_HELP),
 429       IfrOptionList,
 430       2,
 431       &UpdateData->Data
 432       );
 433
 434     UpdateData->DataCount = 4;
 435     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) EFI_VBIOS_CLASS, TRUE, UpdateData);
 436     gBS->FreePool (IfrOptionList);
 437   }
 438
 439   BootDeviceMngrMenuResetRequired = FALSE;
 440   Status = gBrowser->SendForm (
 441                       gBrowser,
 442                       TRUE,                             // Use the database
 443                       &FPCallbackInfo.DevMgrHiiHandle,  // The HII Handle
 444                       1,
 445                       NULL,
 446                       FPCallbackInfo.CallbackHandle,
 447                       (UINT8 *) &FPCallbackInfo.Data,
 448                       NULL,
 449                       &BootDeviceMngrMenuResetRequired
 450                       );
 451
 452   if (BootDeviceMngrMenuResetRequired) {
 453     EnableResetRequired ();
 454   }
 455
 456   Hii->ResetStrings (Hii, FPCallbackInfo.DevMgrHiiHandle);
 457
 458   //
 459   // We will have returned from processing a callback - user either hit ESC to exit, or selected
 460   // a target to display
 461   //
 462   if (gCallbackKey != 0 && gCallbackKey < 0x2000) {
 463     BootDeviceMngrMenuResetRequired = FALSE;
 464     Status = gBrowser->SendForm (
 465                         gBrowser,
 466                         TRUE,                             // Use the database
 467                         (EFI_HII_HANDLE *) &gCallbackKey, // The HII Handle
 468                         1,
 469                         NULL,
 470                         NULL,                             // This is the handle that the interface to the callback was installed on
 471                         NULL,
 472                         NULL,
 473                         &BootDeviceMngrMenuResetRequired
 474                         );
 475
 476     if (BootDeviceMngrMenuResetRequired) {
 477       EnableResetRequired ();
 478     }
 479     //
 480     // Force return to Device Manager
 481     //
 482     gCallbackKey = 4;
 483   }
 484
 485   if (gCallbackKey >= 0x2000) {
 486     gCallbackKey = 4;
 487   }
 488
 489   gBS->FreePool (UpdateData);
 490
 491   return Status;
 492 }