EdkNt32Pkg/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
 201   IfrOptionList       = NULL;
 202   VideoOption         = NULL;
 203   HandleBufferLength  = 0;
 204
 205   //
 206   // Connect all prior to entering the platform setup menu.
 207   //
 208   if (!gConnectAllHappened) {
 209     BdsLibConnectAllDriversToAllControllers ();
 210     gConnectAllHappened = TRUE;
 211   }
 212   //
 213   // Allocate space for creation of UpdateData Buffer
 214   //
 215   UpdateData = AllocateZeroPool (0x1000);
 216   ASSERT (UpdateData != NULL);
 217
 218   Status        = EFI_SUCCESS;
 219   Buffer        = NULL;
 220   FormSetData   = NULL;
 221   gCallbackKey  = 0;
 222   if (mTokenCount == 0) {
 223     Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &mTokenCount, L" ");
 224   }
 225
 226   Token     = mTokenCount;
 227   TokenHelp = (UINT16) (Token + 1);
 228
 229   //
 230   // Reset the menu
 231   //
 232   for (Index = 0, Count = 1; Count < 0x10000; Count <<= 1, Index++) {
 233     //
 234     // We will strip off all previous menu entries
 235     //
 236     UpdateData->DataCount = 0xFF;
 237
 238     //
 239     // Erase entries on this label
 240     //
 241     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, FALSE, UpdateData);
 242
 243     //
 244     // Did we reach the end of the Token Table?
 245     //
 246     if (gStringTokenTable[Index] == 0xFFFF) {
 247       break;
 248     }
 249
 250     CreateSubTitleOpCode (gStringTokenTable[Index], &UpdateData->Data);
 251     //
 252     // Add a single menu item - in this case a subtitle for the device type
 253     //
 254     UpdateData->DataCount = 1;
 255
 256     //
 257     // Add default title for this label
 258     //
 259     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 260   }
 261   //
 262   // Add a space and an exit string.  Remember since we add things at the label and push other things beyond the
 263   // label down, we add this in reverse order
 264   //
 265   CreateSubTitleOpCode (STRING_TOKEN (STR_EXIT_STRING), &UpdateData->Data);
 266   Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 267   CreateSubTitleOpCode (STR_EMPTY_STRING, &UpdateData->Data);
 268   Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
 269
 270   HiiHandles = AllocateZeroPool (HandleBufferLength);
 271   Hii->FindHandles (Hii, &HandleBufferLength, HiiHandles);
 272
 273   for (Index = 1, BufferSize = 0; Index < HandleBufferLength; Index++) {
 274     //
 275     // Am not initializing Buffer since the first thing checked is the size
 276     // this way I can get the real buffersize in the smallest code size
 277     //
 278     Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
 279
 280     if (Status != EFI_NOT_FOUND) {
 281       //
 282       // BufferSize should have the real size of the forms now
 283       //
 284       Buffer = AllocateZeroPool (BufferSize);
 285       ASSERT (Buffer != NULL);
 286
 287       //
 288       // Am not initializing Buffer since the first thing checked is the size
 289       // this way I can get the real buffersize in the smallest code size
 290       //
 291       Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
 292
 293       //
 294       // Skip EFI_HII_PACK_HEADER, advance to EFI_IFR_FORM_SET data.
 295       //
 296       FormSetData = (EFI_IFR_FORM_SET *) (Buffer + sizeof (EFI_HII_PACK_HEADER));
 297
 298       //
 299       // If this formset belongs in the device manager, add it to the menu
 300       //
 301       if (FormSetData->Class != EFI_NON_DEVICE_CLASS) {
 302
 303         StringLength  = 0x1000;
 304         String        = AllocateZeroPool (StringLength);
 305         ASSERT (String != NULL);
 306
 307         Status  = Hii->GetString (Hii, Index, FormSetData->FormSetTitle, TRUE, NULL, &StringLength, String);
 308         Status  = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
 309
 310         //
 311         // If token value exceeded real token value - we need to add a new token values
 312         //
 313         if (Status == EFI_INVALID_PARAMETER) {
 314           Token     = 0;
 315           TokenHelp = 0;
 316           Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
 317         }
 318
 319         StringLength = 0x1000;
 320         if (FormSetData->Help == 0) {
 321           TokenHelp = 0;
 322         } else {
 323           Status = Hii->GetString (Hii, Index, FormSetData->Help, TRUE, NULL, &StringLength, String);
 324           if (StringLength == 0x02) {
 325             TokenHelp = 0;
 326           } else {
 327             Status = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
 328             if (Status == EFI_INVALID_PARAMETER) {
 329               TokenHelp = 0;
 330               Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
 331             }
 332           }
 333         }
 334
 335         gBS->FreePool (String);
 336
 337         CreateGotoOpCode (
 338           0x1000,     // Device Manager Page
 339           Token,      // Description String Token
 340           TokenHelp,  // Description Help String Token
 341           EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,  // Flag designating callback is active
 342           (UINT16) Index,                                     // Callback key value
 343           &UpdateData->Data                                   // Buffer to fill with op-code
 344           );
 345
 346         //
 347         // In the off-chance that we have lots of extra tokens allocated to the DeviceManager
 348         // this ensures we are fairly re-using the tokens instead of constantly growing the token
 349         // storage for this one handle.  If we incremented the token value beyond what it normally
 350         // would use, we will fall back into the error path which seeds the token value with a 0
 351         // so that we can correctly add a token value.
 352         //
 353         if (TokenHelp == 0) {
 354           //
 355           // Since we didn't add help, only advance Token by 1
 356           //
 357           Token++;
 358         } else {
 359           Token     = (UINT16) (Token + 2);
 360           TokenHelp = (UINT16) (TokenHelp + 2);
 361         }
 362         //
 363         // This for loop basically will take the Class value which is a bitmask and
 364         // update the form for every active bit.  There will be a label at each bit
 365         // location.  So if someone had a device which a class of EFI_DISK_DEVICE_CLASS |
 366         // EFI_ON_BOARD_DEVICE_CLASS, this routine will unwind that mask and drop the menu entry
 367         // on each corresponding label.
 368         //
 369         for (Count = 1; Count < 0x10000; Count <<= 1) {
 370           //
 371           // This is an active bit, so update the form
 372           //
 373           if (FormSetData->Class & Count) {
 374             Hii->UpdateForm (
 375                   Hii,
 376                   FPCallbackInfo.DevMgrHiiHandle,
 377                   (EFI_FORM_LABEL) (FormSetData->Class & Count),
 378                   TRUE,
 379                   UpdateData
 380                   );
 381           }
 382         }
 383       }
 384
 385       BufferSize = 0;
 386       //
 387       // Reset Buffer pointer to original location
 388       //
 389       gBS->FreePool (Buffer);
 390     }
 391   }
 392   //
 393   // Add oneof for video BIOS selection
 394   //
 395   VideoOption = BdsLibGetVariableAndSize (
 396                   L"VBIOS",
 397                   &gEfiGlobalVariableGuid,
 398                   &VideoOptionSize
 399                   );
 400   if (NULL == VideoOption) {
 401     FPCallbackInfo.Data.VideoBIOS = 0;
 402   } else {
 403     FPCallbackInfo.Data.VideoBIOS = VideoOption[0];
 404     gBS->FreePool (VideoOption);
 405   }
 406
 407   ASSERT (FPCallbackInfo.Data.VideoBIOS <= 1);
 408
 409   Status = gBS->AllocatePool (EfiBootServicesData, 2 * sizeof (IFR_OPTION), &IfrOptionList);
 410   if (IfrOptionList != NULL) {
 411     IfrOptionList[0].Flags        = EFI_IFR_FLAG_INTERACTIVE;
 412     IfrOptionList[0].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
 413     IfrOptionList[0].StringToken  = STRING_TOKEN (STR_ONE_OF_PCI);
 414     IfrOptionList[0].Value        = 0;
 415     IfrOptionList[0].OptionString = NULL;
 416     IfrOptionList[1].Flags        = EFI_IFR_FLAG_INTERACTIVE;
 417     IfrOptionList[1].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
 418     IfrOptionList[1].StringToken  = STRING_TOKEN (STR_ONE_OF_AGP);
 419     IfrOptionList[1].Value        = 1;
 420     IfrOptionList[1].OptionString = NULL;
 421     IfrOptionList[FPCallbackInfo.Data.VideoBIOS].Flags |= EFI_IFR_FLAG_DEFAULT;
 422
 423     CreateOneOfOpCode (
 424       SET_VIDEO_BIOS_TYPE_QUESTION_ID,
 425       (UINT8) 1,
 426       STRING_TOKEN (STR_ONE_OF_VBIOS),
 427       STRING_TOKEN (STR_ONE_OF_VBIOS_HELP),
 428       IfrOptionList,
 429       2,
 430       &UpdateData->Data
 431       );
 432
 433     UpdateData->DataCount = 4;
 434     Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) EFI_VBIOS_CLASS, TRUE, UpdateData);
 435     gBS->FreePool (IfrOptionList);
 436   }
 437
 438   Status = gBrowser->SendForm (
 439                       gBrowser,
 440                       TRUE,                             // Use the database
 441                       &FPCallbackInfo.DevMgrHiiHandle,  // The HII Handle
 442                       1,
 443                       NULL,
 444                       FPCallbackInfo.CallbackHandle,
 445                       (UINT8 *) &FPCallbackInfo.Data,
 446                       NULL,
 447                       NULL
 448                       );
 449
 450   Hii->ResetStrings (Hii, FPCallbackInfo.DevMgrHiiHandle);
 451
 452   //
 453   // We will have returned from processing a callback - user either hit ESC to exit, or selected
 454   // a target to display
 455   //
 456   if (gCallbackKey != 0 && gCallbackKey < 0x2000) {
 457     Status = gBrowser->SendForm (
 458                         gBrowser,
 459                         TRUE,                             // Use the database
 460                         (EFI_HII_HANDLE *) &gCallbackKey, // The HII Handle
 461                         1,
 462                         NULL,
 463                         NULL,                             // This is the handle that the interface to the callback was installed on
 464                         NULL,
 465                         NULL,
 466                         NULL
 467                         );
 468
 469     //
 470     // Force return to Device Manager
 471     //
 472     gCallbackKey = 4;
 473   }
 474
 475   if (gCallbackKey >= 0x2000) {
 476     gCallbackKey = 4;
 477   }
 478
 479   gBS->FreePool (UpdateData);
 480
 481   return Status;
 482 }