EdkCompatibilityPkg/Compatibility/FrameworkHiiToUefiHiiThunk/HiiDatabase.c

   1 /**@file
   2 Framework to UEFI 2.1 HII Thunk. The driver consume UEFI HII protocols
   3 to produce a Framework HII protocol.
   4
   5 Copyright (c) 2008, Intel Corporation
   6 All rights reserved. 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 #include "HiiDatabase.h"
  17
  18 EFI_HII_THUNK_PRIVATE_DATA *mHiiThunkPrivateData;
  19
  20 EFI_HII_THUNK_PRIVATE_DATA mHiiThunkPrivateDataTempate = {
  21   //Signature
  22   EFI_HII_THUNK_DRIVER_DATA_SIGNATURE
  23   ,
  24   //Handle
  25   (EFI_HANDLE) NULL
  26   ,
  27   { //Hii
  28     HiiNewPack,
  29     HiiRemovePack,
  30     HiiFindHandles,
  31     HiiExportDatabase,
  32
  33     HiiTestString,
  34     HiiGetGlyph,
  35     HiiGlyphToBlt,
  36
  37     HiiNewString,
  38     HiiGetPrimaryLanguages,
  39     HiiGetSecondaryLanguages,
  40     HiiGetString,
  41     HiiResetStrings,
  42     HiiGetLine,
  43     HiiGetForms,
  44     HiiGetDefaultImage,
  45     HiiUpdateForm,
  46
  47     HiiGetKeyboardLayout
  48   },
  49   //StaticHiiHandle
  50   //The FRAMEWORK_EFI_HII_HANDLE starts from 1
  51   // and increase upwords untill reach the value of StaticPureUefiHiiHandle.
  52   // The code will assert to prevent overflow.
  53   (FRAMEWORK_EFI_HII_HANDLE) 1
  54   ,
  55   //StaticPureUefiHiiHandle
  56   //The Static FRAMEWORK_EFI_HII_HANDLE starts from 0xFFFF
  57   // and decrease downwords untill reach the value of StaticHiiHandle.
  58   // The code will assert to prevent overflow.
  59   (FRAMEWORK_EFI_HII_HANDLE) 0xFFFF
  60   ,
  61   {
  62     NULL, NULL                  //HiiHandleLinkList
  63   },
  64 };
  65
  66 EFI_FORMBROWSER_THUNK_PRIVATE_DATA mBrowserThunkPrivateDataTemplate = {
  67   EFI_FORMBROWSER_THUNK_PRIVATE_DATA_SIGNATURE,
  68   (EFI_HANDLE) NULL,
  69   {
  70     ThunkSendForm,
  71     ThunkCreatePopUp
  72   }
  73 };
  74
  75
  76 CONST EFI_HII_DATABASE_PROTOCOL            *mHiiDatabase;
  77 CONST EFI_HII_FONT_PROTOCOL                *mHiiFontProtocol;
  78 CONST EFI_HII_IMAGE_PROTOCOL               *mHiiImageProtocol;
  79 CONST EFI_HII_STRING_PROTOCOL              *mHiiStringProtocol;
  80 CONST EFI_HII_CONFIG_ROUTING_PROTOCOL      *mHiiConfigRoutingProtocol;
  81
  82 EFI_STATUS
  83 RegisterUefiHiiHandle (
  84   EFI_HII_THUNK_PRIVATE_DATA *Private,
  85   EFI_HII_HANDLE             UefiHiiHandle
  86  )
  87 {
  88   EFI_STATUS     Status;
  89   EFI_GUID       PackageGuid;
  90   HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY *HandleMappingEntry;
  91
  92   HandleMappingEntry = AllocateZeroPool (sizeof (*HandleMappingEntry));
  93   HandleMappingEntry->Signature = HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY_SIGNATURE;
  94
  95   Status = AssignPureUefiHiiHandle (Private, &HandleMappingEntry->FrameworkHiiHandle);
  96   if (EFI_ERROR (Status)) {
  97     return Status;
  98   }
  99
 100   HandleMappingEntry->UefiHiiHandle = UefiHiiHandle;
 101   Status = HiiLibExtractGuidFromHiiHandle (UefiHiiHandle, &PackageGuid);
 102   ASSERT_EFI_ERROR (Status);
 103
 104   CopyGuid(&HandleMappingEntry->TagGuid, &PackageGuid);
 105
 106   InsertTailList (&Private->HiiThunkHandleMappingDBListHead, &HandleMappingEntry->List);
 107
 108   return EFI_SUCCESS;
 109 }
 110
 111
 112 EFI_STATUS
 113 UnRegisterUefiHiiHandle (
 114   EFI_HII_THUNK_PRIVATE_DATA *Private,
 115   EFI_HII_HANDLE UefiHiiHandle
 116  )
 117 {
 118   HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY     *MapEntry;
 119
 120   MapEntry = UefiHiiHandleToMapDatabaseEntry (Private, UefiHiiHandle);
 121   ASSERT (MapEntry != NULL);
 122
 123   RemoveEntryList (&MapEntry->List);
 124
 125   FreePool (MapEntry);
 126
 127   return EFI_SUCCESS;
 128 }
 129
 130 EFI_STATUS
 131 EFIAPI
 132 AddPackNotify (
 133   IN UINT8                              PackageType,
 134   IN CONST EFI_GUID                     *PackageGuid,
 135   IN CONST EFI_HII_PACKAGE_HEADER       *Package,
 136   IN EFI_HII_HANDLE                     Handle,
 137   IN EFI_HII_DATABASE_NOTIFY_TYPE       NotifyType
 138   )
 139 {
 140   EFI_STATUS   Status;
 141   EFI_HII_THUNK_PRIVATE_DATA *Private;
 142
 143   ASSERT (PackageType == EFI_HII_PACKAGE_STRINGS);
 144   ASSERT (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK);
 145
 146   Status  = EFI_SUCCESS;
 147   Private = mHiiThunkPrivateData;
 148
 149   if (mInFrameworkHiiNewPack) {
 150     return EFI_SUCCESS;
 151   }
 152
 153   //
 154   // We only create a MapEntry if the Uefi Hii Handle is only already registered
 155   // by the HII Thunk Layer.
 156   //
 157   if (UefiHiiHandleToMapDatabaseEntry (Private, Handle) == NULL) {
 158     Status = RegisterUefiHiiHandle (Private, Handle);
 159   }
 160
 161   return Status;
 162 }
 163 EFI_STATUS
 164 EFIAPI
 165 NewPackNotify (
 166   IN UINT8                              PackageType,
 167   IN CONST EFI_GUID                     *PackageGuid,
 168   IN CONST EFI_HII_PACKAGE_HEADER       *Package,
 169   IN EFI_HII_HANDLE                     Handle,
 170   IN EFI_HII_DATABASE_NOTIFY_TYPE       NotifyType
 171   )
 172 {
 173   EFI_STATUS   Status;
 174   EFI_HII_THUNK_PRIVATE_DATA *Private;
 175
 176   ASSERT (PackageType == EFI_HII_PACKAGE_STRINGS);
 177   ASSERT (NotifyType == EFI_HII_DATABASE_NOTIFY_NEW_PACK);
 178
 179   if (mInFrameworkHiiNewPack) {
 180     return EFI_SUCCESS;
 181   }
 182
 183   Status  = EFI_SUCCESS;
 184   Private = mHiiThunkPrivateData;
 185
 186   //
 187   // We only
 188   //
 189   if (UefiHiiHandleToMapDatabaseEntry (Private, Handle) == NULL) {
 190     Status = RegisterUefiHiiHandle (Private, Handle);
 191   }
 192
 193   return Status;
 194 }
 195
 196 BOOLEAN
 197 IsLastStringPack (
 198   IN CONST EFI_HII_PACKAGE_HEADER       *Package,
 199   IN EFI_HII_HANDLE                     Handle
 200   )
 201 {
 202   EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
 203   UINTN                        BufferSize;
 204   EFI_STATUS                   Status;
 205   EFI_HII_PACKAGE_HEADER       *PackageHdrPtr;
 206   EFI_HII_PACKAGE_HEADER       PackageHeader;
 207   BOOLEAN                      Match;
 208
 209   Match = FALSE;
 210   HiiPackageList = NULL;
 211   BufferSize = 0;
 212   Status = mHiiDatabase->ExportPackageLists (mHiiDatabase, Handle, &BufferSize, HiiPackageList);
 213   ASSERT (Status != EFI_NOT_FOUND);
 214
 215   if (Status == EFI_BUFFER_TOO_SMALL) {
 216     HiiPackageList = AllocateZeroPool (BufferSize);
 217     ASSERT (HiiPackageList != NULL);
 218
 219     Status = mHiiDatabase->ExportPackageLists (mHiiDatabase, Handle, &BufferSize, HiiPackageList);
 220   }
 221
 222
 223   PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) HiiPackageList + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
 224   CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
 225
 226   Status = EFI_SUCCESS;
 227
 228   while (PackageHeader.Type != EFI_HII_PACKAGE_END) {
 229     switch (PackageHeader.Type) {
 230       case EFI_HII_PACKAGE_STRINGS:
 231         if (CompareMem (Package, PackageHdrPtr, Package->Length) != 0) {
 232           FreePool (HiiPackageList);
 233           return FALSE;
 234         }
 235       break;
 236       default:
 237         break;
 238     }
 239     //
 240     // goto header of next package
 241     //
 242     PackageHdrPtr = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageHdrPtr + PackageHeader.Length);
 243     CopyMem (&PackageHeader, PackageHdrPtr, sizeof (EFI_HII_PACKAGE_HEADER));
 244   }
 245
 246   FreePool (HiiPackageList);
 247   return TRUE;
 248 }
 249
 250 EFI_STATUS
 251 EFIAPI
 252 RemovePackNotify (
 253   IN UINT8                              PackageType,
 254   IN CONST EFI_GUID                     *PackageGuid,
 255   IN CONST EFI_HII_PACKAGE_HEADER       *Package,
 256   IN EFI_HII_HANDLE                     Handle,
 257   IN EFI_HII_DATABASE_NOTIFY_TYPE       NotifyType
 258   )
 259 {
 260   EFI_STATUS   Status;
 261   EFI_HII_THUNK_PRIVATE_DATA *Private;
 262   HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY * MapEntry;
 263
 264   Status = EFI_SUCCESS;
 265
 266   ASSERT (PackageType == EFI_HII_PACKAGE_STRINGS);
 267   ASSERT (NotifyType == EFI_HII_DATABASE_NOTIFY_REMOVE_PACK);
 268
 269   if (mInFrameworkHiiRemovePack) {
 270     return EFI_SUCCESS;
 271   }
 272
 273   Private = mHiiThunkPrivateData;
 274
 275   MapEntry = UefiHiiHandleToMapDatabaseEntry (Private, Handle);
 276
 277   if (MapEntry->FrameworkHiiHandle > Private->StaticHiiHandle) {
 278     //
 279     // This is a PackageList registered using UEFI HII Protocol Instance.
 280     // The MapEntry->TagGuid for this type of PackageList is a auto generated GUID
 281     // to link StringPack with IfrPack.
 282     // RemovePackNotify is only used to remove PackageList when it is removed by
 283     // calling mHiiDatabase->RemovePackageList interface.
 284     if (IsLastStringPack (Package, Handle)) {
 285       Status = UnRegisterUefiHiiHandle (Private, Handle);
 286     }
 287   }
 288
 289   return Status;
 290 }
 291
 292 EFI_STATUS
 293 EFIAPI
 294 MapUefiHiiHandles (
 295   EFI_HII_THUNK_PRIVATE_DATA *Private
 296   )
 297 {
 298   UINTN          HandleBufferLength;
 299   EFI_HII_HANDLE *HandleBuffer;
 300   EFI_STATUS     Status;
 301   UINTN          Index;
 302   HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY * MapEntry;
 303
 304   HandleBufferLength = 0;
 305   HandleBuffer       = NULL;
 306   Status = mHiiDatabase->ListPackageLists (
 307                             mHiiDatabase,
 308                             EFI_HII_PACKAGE_TYPE_ALL,
 309                             NULL,
 310                             &HandleBufferLength,
 311                             HandleBuffer
 312                             );
 313   if (EFI_ERROR (Status) && (Status != EFI_BUFFER_TOO_SMALL)) {
 314     //
 315     // As no package is registered to UEFI HII Database, EFI_SUCCESS is returned.
 316     //
 317     //
 318     if (Status == EFI_NOT_FOUND) {
 319       return EFI_SUCCESS;
 320     } else {
 321       return Status;
 322     }
 323   }
 324
 325   HandleBuffer = AllocateZeroPool (HandleBufferLength);
 326   Status = mHiiDatabase->ListPackageLists (
 327                             mHiiDatabase,
 328                             EFI_HII_PACKAGE_TYPE_ALL,
 329                             NULL,
 330                             &HandleBufferLength,
 331                             HandleBuffer
 332                             );
 333
 334   for (Index = 0; Index < HandleBufferLength / sizeof (EFI_HII_HANDLE); Index++) {
 335     MapEntry = UefiHiiHandleToMapDatabaseEntry (Private, HandleBuffer[Index]);
 336     //
 337     // Only register those UEFI HII Handles that are registered using the UEFI HII database interface.
 338     //
 339     if (MapEntry == NULL) {
 340       Status = RegisterUefiHiiHandle (Private, HandleBuffer[Index]);
 341       ASSERT_EFI_ERROR (Status);
 342     }
 343   }
 344
 345   return EFI_SUCCESS;
 346 }
 347
 348 EFI_STATUS
 349 EFIAPI
 350 InitializeHiiDatabase (
 351   IN EFI_HANDLE           ImageHandle,
 352   IN EFI_SYSTEM_TABLE     *SystemTable
 353   )
 354 /*++
 355
 356 Routine Description:
 357   Initialize HII Database
 358
 359 Arguments:
 360   (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
 361
 362 Returns:
 363   EFI_SUCCESS - Setup loaded.
 364   other       - Setup Error
 365
 366 --*/
 367 {
 368   EFI_HII_THUNK_PRIVATE_DATA *HiiData;
 369   EFI_HANDLE                 Handle;
 370   EFI_STATUS                 Status;
 371
 372   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiHiiProtocolGuid);
 373
 374   HiiData = AllocateCopyPool (sizeof (EFI_HII_THUNK_PRIVATE_DATA), &mHiiThunkPrivateDataTempate);
 375   ASSERT (HiiData != NULL);
 376   InitializeListHead (&HiiData->HiiThunkHandleMappingDBListHead);
 377
 378   mHiiThunkPrivateData = HiiData;
 379
 380   Status = gBS->LocateProtocol (
 381                   &gEfiHiiDatabaseProtocolGuid,
 382                   NULL,
 383                   (VOID **) &mHiiDatabase
 384                   );
 385   ASSERT_EFI_ERROR (Status);
 386
 387   Status = gBS->LocateProtocol (
 388                   &gEfiHiiFontProtocolGuid,
 389                   NULL,
 390                   (VOID **) &mHiiFontProtocol
 391                   );
 392   ASSERT_EFI_ERROR (Status);
 393
 394   Status = gBS->LocateProtocol (
 395                   &gEfiHiiImageProtocolGuid,
 396                   NULL,
 397                   (VOID **) &mHiiImageProtocol
 398                   );
 399   ASSERT_EFI_ERROR (Status);
 400
 401   Status = gBS->LocateProtocol (
 402                   &gEfiHiiStringProtocolGuid,
 403                   NULL,
 404                   (VOID **) &mHiiStringProtocol
 405                   );
 406   ASSERT_EFI_ERROR (Status);
 407
 408   Status = gBS->LocateProtocol (
 409                   &gEfiHiiConfigRoutingProtocolGuid,
 410                   NULL,
 411                   (VOID **) &mHiiConfigRoutingProtocol
 412                   );
 413   ASSERT_EFI_ERROR (Status);
 414
 415   //
 416   // Install protocol interface
 417   //
 418   Handle = NULL;
 419   Status = gBS->InstallProtocolInterface (
 420                   &HiiData->Handle,
 421                   &gEfiHiiProtocolGuid,
 422                   EFI_NATIVE_INTERFACE,
 423                   (VOID *) &HiiData->Hii
 424                   );
 425   ASSERT_EFI_ERROR (Status);
 426
 427   Status = MapUefiHiiHandles (HiiData);
 428   ASSERT_EFI_ERROR (Status);
 429
 430   Status = mHiiDatabase->RegisterPackageNotify (
 431                            mHiiDatabase,
 432                            EFI_HII_PACKAGE_STRINGS,
 433                            NULL,
 434                            NewPackNotify,
 435                            EFI_HII_DATABASE_NOTIFY_NEW_PACK,
 436                            &HiiData->NewPackNotifyHandle
 437                            );
 438   ASSERT_EFI_ERROR (Status);
 439
 440   Status = mHiiDatabase->RegisterPackageNotify (
 441                            mHiiDatabase,
 442                            EFI_HII_PACKAGE_STRINGS,
 443                            NULL,
 444                            AddPackNotify,
 445                            EFI_HII_DATABASE_NOTIFY_ADD_PACK,
 446                            &HiiData->AddPackNotifyHandle
 447                            );
 448   ASSERT_EFI_ERROR (Status);
 449
 450   Status = mHiiDatabase->RegisterPackageNotify (
 451                            mHiiDatabase,
 452                            EFI_HII_PACKAGE_STRINGS,
 453                            NULL,
 454                            RemovePackNotify,
 455                            EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
 456                            &HiiData->RemovePackNotifyHandle
 457                            );
 458   ASSERT_EFI_ERROR (Status);
 459
 460   Status = gBS->InstallProtocolInterface (
 461                   &mBrowserThunkPrivateDataTemplate.Handle,
 462                   &gEfiFormBrowserProtocolGuid,
 463                   EFI_NATIVE_INTERFACE,
 464                   (VOID *) &mBrowserThunkPrivateDataTemplate.FormBrowser
 465                   );
 466   ASSERT_EFI_ERROR (Status);
 467
 468   return Status;
 469 }
 470
 471 EFI_STATUS
 472 EFIAPI
 473 HiiFindHandles (
 474   IN     EFI_HII_PROTOCOL *This,
 475   IN OUT UINT16           *HandleBufferLength,
 476   OUT    FRAMEWORK_EFI_HII_HANDLE    Handle[1]
 477   )
 478 /*++
 479
 480 Routine Description:
 481   Determines the handles that are currently active in the database.
 482
 483 Arguments:
 484
 485 Returns:
 486
 487 --*/
 488 {
 489   UINT16                                     Count;
 490   LIST_ENTRY                                *ListEntry;
 491   HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY *HandleMapEntry;
 492   EFI_HII_THUNK_PRIVATE_DATA               *Private;
 493
 494   if (HandleBufferLength == NULL) {
 495     return EFI_INVALID_PARAMETER;
 496   }
 497
 498   Private = EFI_HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 499
 500   Count = 0;
 501   for (ListEntry = Private->HiiThunkHandleMappingDBListHead.ForwardLink;
 502        ListEntry != &Private->HiiThunkHandleMappingDBListHead;
 503        ListEntry = ListEntry->ForwardLink
 504        ) {
 505     Count++;
 506   }
 507
 508   if (Count > *HandleBufferLength) {
 509     *HandleBufferLength = (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 510     return EFI_BUFFER_TOO_SMALL;
 511   }
 512
 513   Count = 0;
 514   for (ListEntry = Private->HiiThunkHandleMappingDBListHead.ForwardLink;
 515        ListEntry != &Private->HiiThunkHandleMappingDBListHead;
 516        ListEntry = ListEntry->ForwardLink
 517        ) {
 518     HandleMapEntry = HII_TRHUNK_HANDLE_MAPPING_DATABASE_ENTRY_FROM_LISTENTRY (ListEntry);
 519
 520     Handle[Count] = HandleMapEntry->FrameworkHiiHandle;
 521
 522     Count++;
 523   }
 524
 525   *HandleBufferLength = (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 526   return EFI_SUCCESS;
 527 }
 528
 529 EFI_STATUS
 530 EFIAPI
 531 HiiGetPrimaryLanguages (
 532   IN  EFI_HII_PROTOCOL      *This,
 533   IN  FRAMEWORK_EFI_HII_HANDLE         Handle,
 534   OUT EFI_STRING            *LanguageString
 535   )
 536 /*++
 537
 538 Routine Description:
 539
 540   This function allows a program to determine what the primary languages that are supported on a given handle.
 541
 542 Arguments:
 543
 544 Returns:
 545
 546 --*/
 547 {
 548   EFI_HII_THUNK_PRIVATE_DATA *Private;
 549   EFI_HII_HANDLE             UefiHiiHandle;
 550   CHAR8                      *AsciiLanguageCodes;
 551   CHAR16                     *UnicodeLanguageCodes;
 552
 553   Private = EFI_HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 554
 555
 556
 557   UefiHiiHandle = FrameworkHiiHandleToUefiHiiHandle (Private, Handle);
 558   if (UefiHiiHandle == NULL) {
 559     return EFI_INVALID_PARAMETER;
 560   }
 561
 562   AsciiLanguageCodes = HiiLibGetSupportedLanguages (UefiHiiHandle);
 563
 564   if (AsciiLanguageCodes == NULL) {
 565     return EFI_INVALID_PARAMETER;
 566   }
 567
 568   UnicodeLanguageCodes = AllocateZeroPool (AsciiStrSize (AsciiLanguageCodes) * sizeof (CHAR16));
 569   if (UnicodeLanguageCodes == NULL) {
 570     return EFI_OUT_OF_RESOURCES;
 571   }
 572
 573   //
 574   // The language returned is in RFC 3066 format.
 575   //
 576   *LanguageString = AsciiStrToUnicodeStr (AsciiLanguageCodes, UnicodeLanguageCodes);
 577
 578   return EFI_SUCCESS;
 579 }
 580
 581 EFI_STATUS
 582 EFIAPI
 583 HiiGetSecondaryLanguages (
 584   IN  EFI_HII_PROTOCOL      *This,
 585   IN  FRAMEWORK_EFI_HII_HANDLE         Handle,
 586   IN  CHAR16                *PrimaryLanguage,
 587   OUT EFI_STRING            *LanguageString
 588   )
 589 /*++
 590
 591 Routine Description:
 592
 593   This function allows a program to determine which secondary languages are supported
 594   on a given handle for a given primary language.
 595
 596   Arguments:
 597
 598 Returns:
 599
 600 --*/
 601 {
 602   EFI_HII_THUNK_PRIVATE_DATA *Private;
 603   EFI_HII_HANDLE             UefiHiiHandle;
 604   CHAR8                      *AsciiPrimaryLanguage;
 605   CHAR8                      *AsciiLanguageCodes;
 606   CHAR16                     *UnicodeLanguageCodes;
 607
 608   Private = EFI_HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 609
 610
 611
 612   UefiHiiHandle = FrameworkHiiHandleToUefiHiiHandle (Private, Handle);
 613   if (UefiHiiHandle == NULL) {
 614     return EFI_INVALID_PARAMETER;
 615   }
 616
 617   AsciiPrimaryLanguage = AllocateZeroPool (StrLen (PrimaryLanguage) + 1);
 618
 619   UnicodeStrToAsciiStr (PrimaryLanguage, AsciiPrimaryLanguage);
 620
 621   AsciiLanguageCodes = HiiLibGetSupportedSecondaryLanguages (UefiHiiHandle, AsciiPrimaryLanguage);
 622
 623   if (AsciiLanguageCodes == NULL) {
 624     return EFI_INVALID_PARAMETER;
 625   }
 626
 627   UnicodeLanguageCodes = AllocateZeroPool (AsciiStrSize (AsciiLanguageCodes) * sizeof (CHAR16));
 628   if (UnicodeLanguageCodes == NULL) {
 629     return EFI_OUT_OF_RESOURCES;
 630   }
 631
 632   //
 633   // The language returned is in RFC 3066 format.
 634   //
 635   *LanguageString = AsciiStrToUnicodeStr (AsciiLanguageCodes, UnicodeLanguageCodes);
 636
 637   return EFI_SUCCESS;
 638 }
 639
 640 EFI_STATUS
 641 EFIAPI
 642 ThunkSendForm (
 643   IN  EFI_FORM_BROWSER_PROTOCOL       *This,
 644   IN  BOOLEAN                         UseDatabase,
 645   IN  FRAMEWORK_EFI_HII_HANDLE        *Handle,
 646   IN  UINTN                           HandleCount,
 647   IN  FRAMEWORK_EFI_IFR_PACKET                  *Packet, OPTIONAL
 648   IN  EFI_HANDLE                      CallbackHandle, OPTIONAL
 649   IN  UINT8                           *NvMapOverride, OPTIONAL
 650   IN  FRAMEWORK_EFI_SCREEN_DESCRIPTOR            *ScreenDimensions, OPTIONAL
 651   OUT BOOLEAN                         *ResetRequired OPTIONAL
 652   )
 653 {
 654   ASSERT (FALSE);
 655   return EFI_UNSUPPORTED;
 656 }
 657
 658 EFI_STATUS
 659 EFIAPI
 660 ThunkCreatePopUp (
 661   IN  UINTN                           NumberOfLines,
 662   IN  BOOLEAN                         HotKey,
 663   IN  UINTN                           MaximumStringSize,
 664   OUT CHAR16                          *StringBuffer,
 665   OUT EFI_INPUT_KEY                   *KeyValue,
 666   IN  CHAR16                          *String,
 667   ...
 668   )
 669 {
 670   ASSERT (FALSE);
 671   return EFI_UNSUPPORTED;
 672 }
 673