EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/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 #include "HiiHandle.h"
  18
  19 HII_THUNK_PRIVATE_DATA *mHiiThunkPrivateData;
  20
  21 HII_THUNK_PRIVATE_DATA mHiiThunkPrivateDataTempate = {
  22   HII_THUNK_PRIVATE_DATA_SIGNATURE,
  23   (EFI_HANDLE) NULL,
  24   {
  25     HiiNewPack,
  26     HiiRemovePack,
  27     HiiFindHandles,
  28     HiiExportDatabase,
  29
  30     HiiTestString,
  31     HiiGetGlyph,
  32     HiiGlyphToBlt,
  33
  34     HiiNewString,
  35     HiiGetPrimaryLanguages,
  36     HiiGetSecondaryLanguages,
  37     HiiThunkGetString,
  38     HiiResetStrings,
  39     HiiGetLine,
  40     HiiGetForms,
  41     HiiGetDefaultImage,
  42     HiiThunkUpdateForm,
  43
  44     HiiGetKeyboardLayout
  45   },
  46
  47   {
  48     ///
  49     /// HiiHandleLinkList
  50     ///
  51     NULL, NULL
  52   },
  53 };
  54
  55 EFI_FORMBROWSER_THUNK_PRIVATE_DATA mBrowserThunkPrivateDataTemplate = {
  56   EFI_FORMBROWSER_THUNK_PRIVATE_DATA_SIGNATURE,
  57   (EFI_HANDLE) NULL,
  58   (HII_THUNK_PRIVATE_DATA *) NULL,
  59   {
  60     ThunkSendForm,
  61     ThunkCreatePopUp
  62   }
  63 };
  64
  65
  66 CONST EFI_HII_DATABASE_PROTOCOL            *mHiiDatabase;
  67 CONST EFI_HII_IMAGE_PROTOCOL               *mHiiImageProtocol;
  68 CONST EFI_HII_STRING_PROTOCOL              *mHiiStringProtocol;
  69 CONST EFI_HII_FONT_PROTOCOL                *mHiiFontProtocol;
  70 CONST EFI_HII_CONFIG_ROUTING_PROTOCOL      *mHiiConfigRoutingProtocol;
  71 CONST EFI_FORM_BROWSER2_PROTOCOL           *mFormBrowser2Protocol;
  72
  73
  74 /**
  75   This routine initializes the HII Database.
  76
  77   @param ImageHandle     Image handle for PCD DXE driver.
  78   @param SystemTable     Pointer to SystemTable.
  79
  80   @retval  EFI_SUCCESS   The entry point alwasy return successfully.
  81 **/
  82 EFI_STATUS
  83 EFIAPI
  84 InitializeHiiDatabase (
  85   IN EFI_HANDLE           ImageHandle,
  86   IN EFI_SYSTEM_TABLE     *SystemTable
  87   )
  88 {
  89   HII_THUNK_PRIVATE_DATA *Private;
  90   EFI_HANDLE              Handle;
  91   EFI_STATUS              Status;
  92   UINTN                   BufferLength;
  93   EFI_HII_HANDLE          *Buffer;
  94   UINTN                   Index;
  95   HII_THUNK_CONTEXT       *ThunkContext;
  96
  97
  98   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiHiiCompatibilityProtocolGuid);
  99   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiFormBrowserCompatibilityProtocolGuid);
 100
 101   Private = AllocateCopyPool (sizeof (HII_THUNK_PRIVATE_DATA), &mHiiThunkPrivateDataTempate);
 102   ASSERT (Private != NULL);
 103   InitializeListHead (&Private->ThunkContextListHead);
 104
 105   InitHiiHandleDatabase ();
 106
 107   mHiiThunkPrivateData = Private;
 108
 109   Status = gBS->LocateProtocol (
 110                   &gEfiHiiDatabaseProtocolGuid,
 111                   NULL,
 112                   (VOID **) &mHiiDatabase
 113                   );
 114   ASSERT_EFI_ERROR (Status);
 115
 116   Status = gBS->LocateProtocol (
 117                   &gEfiHiiStringProtocolGuid,
 118                   NULL,
 119                   (VOID **) &mHiiStringProtocol
 120                   );
 121   ASSERT_EFI_ERROR (Status);
 122
 123   Status = gBS->LocateProtocol (
 124                   &gEfiHiiFontProtocolGuid,
 125                   NULL,
 126                   (VOID **) &mHiiFontProtocol
 127                   );
 128   ASSERT_EFI_ERROR (Status);
 129
 130   Status = gBS->LocateProtocol (
 131                   &gEfiHiiConfigRoutingProtocolGuid,
 132                   NULL,
 133                   (VOID **) &mHiiConfigRoutingProtocol
 134                   );
 135   ASSERT_EFI_ERROR (Status);
 136
 137
 138   Status = gBS->LocateProtocol (
 139                   &gEfiFormBrowser2ProtocolGuid,
 140                   NULL,
 141                   (VOID **) &mFormBrowser2Protocol
 142                   );
 143   ASSERT_EFI_ERROR (Status);
 144
 145
 146
 147
 148   //
 149   // Install protocol interface
 150   //
 151   Status = gBS->InstallProtocolInterface (
 152                   &Private->Handle,
 153                   &gEfiHiiCompatibilityProtocolGuid,
 154                   EFI_NATIVE_INTERFACE,
 155                   (VOID *) &Private->Hii
 156                   );
 157   ASSERT_EFI_ERROR (Status);
 158
 159   Status = HiiLibListPackageLists (EFI_HII_PACKAGE_STRINGS, NULL, &BufferLength, &Buffer);
 160   if (Status == EFI_SUCCESS) {
 161     for (Index = 0; Index < BufferLength / sizeof (EFI_HII_HANDLE); Index++) {
 162       ThunkContext = CreateThunkContextForUefiHiiHandle (Buffer[Index]);
 163       ASSERT (ThunkContext!= NULL);
 164
 165       InsertTailList (&Private->ThunkContextListHead, &ThunkContext->Link);
 166     }
 167
 168     FreePool (Buffer);
 169   }
 170
 171   Status = mHiiDatabase->RegisterPackageNotify (
 172                            mHiiDatabase,
 173                            EFI_HII_PACKAGE_STRINGS,
 174                            NULL,
 175                            NewOrAddPackNotify,
 176                            EFI_HII_DATABASE_NOTIFY_NEW_PACK,
 177                            &Handle
 178                            );
 179   ASSERT_EFI_ERROR (Status);
 180
 181   Status = mHiiDatabase->RegisterPackageNotify (
 182                            mHiiDatabase,
 183                            EFI_HII_PACKAGE_STRINGS,
 184                            NULL,
 185                            NewOrAddPackNotify,
 186                            EFI_HII_DATABASE_NOTIFY_ADD_PACK,
 187                            &Handle
 188                            );
 189   ASSERT_EFI_ERROR (Status);
 190
 191   Status = mHiiDatabase->RegisterPackageNotify (
 192                            mHiiDatabase,
 193                            EFI_HII_PACKAGE_FORMS,
 194                            NULL,
 195                            NewOrAddPackNotify,
 196                            EFI_HII_DATABASE_NOTIFY_NEW_PACK,
 197                            &Handle
 198                            );
 199   ASSERT_EFI_ERROR (Status);
 200
 201   Status = mHiiDatabase->RegisterPackageNotify (
 202                            mHiiDatabase,
 203                            EFI_HII_PACKAGE_FORMS,
 204                            NULL,
 205                            NewOrAddPackNotify,
 206                            EFI_HII_DATABASE_NOTIFY_ADD_PACK,
 207                            &Handle
 208                            );
 209   ASSERT_EFI_ERROR (Status);
 210
 211   Status = mHiiDatabase->RegisterPackageNotify (
 212                            mHiiDatabase,
 213                            EFI_HII_PACKAGE_STRINGS,
 214                            NULL,
 215                            RemovePackNotify,
 216                            EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
 217                            &Handle
 218                            );
 219   ASSERT_EFI_ERROR (Status);
 220
 221   InitSetBrowserStrings ();
 222
 223   mBrowserThunkPrivateDataTemplate.ThunkPrivate = Private;
 224   Status = gBS->InstallProtocolInterface (
 225                   &mBrowserThunkPrivateDataTemplate.Handle,
 226                   &gEfiFormBrowserCompatibilityProtocolGuid,
 227                   EFI_NATIVE_INTERFACE,
 228                   (VOID *) &mBrowserThunkPrivateDataTemplate.FormBrowser
 229                   );
 230   ASSERT_EFI_ERROR (Status);
 231
 232   return Status;
 233 }
 234
 235 /**
 236   Determines the handles that are currently active in the database.
 237
 238   This function determines the handles that are currently active in the database.
 239   For example, a program wishing to create a Setup-like configuration utility would use this call
 240   to determine the handles that are available. It would then use calls defined in the forms section
 241   below to extract forms and then interpret them.
 242
 243   @param This                 A pointer to the EFI_HII_PROTOCOL instance.
 244   @param HandleBufferLength   On input, a pointer to the length of the handle buffer.
 245                               On output, the length of the handle buffer that is required for the handles found.
 246   @param Handle               An array of EFI_HII_HANDLE instances returned.
 247                               Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack() in the Packages section.
 248
 249   @retval EFI_SUCCESS         Handle was updated successfully.
 250
 251   @retval EFI_BUFFER_TOO_SMALL The HandleBufferLength parameter indicates that Handle is too small
 252                                to support the number of handles. HandleBufferLength is updated with a value that
 253                                will enable the data to fit.
 254 **/
 255 EFI_STATUS
 256 EFIAPI
 257 HiiFindHandles (
 258   IN     EFI_HII_PROTOCOL *This,
 259   IN OUT UINT16           *HandleBufferLength,
 260   OUT    FRAMEWORK_EFI_HII_HANDLE    Handle[1]
 261   )
 262 {
 263   UINT16                                     Count;
 264   LIST_ENTRY                                *Link;
 265   HII_THUNK_CONTEXT *ThunkContext;
 266   HII_THUNK_PRIVATE_DATA               *Private;
 267
 268   if (HandleBufferLength == NULL) {
 269     return EFI_INVALID_PARAMETER;
 270   }
 271
 272   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 273
 274   //
 275   // Count the number of handles.
 276   //
 277   Count = 0;
 278   Link = GetFirstNode (&Private->ThunkContextListHead);
 279   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 280     Count++;
 281     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 282   }
 283
 284   if (Count > *HandleBufferLength) {
 285     *HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 286     return EFI_BUFFER_TOO_SMALL;
 287   }
 288
 289   //
 290   // Output the handles.
 291   //
 292   Count = 0;
 293   Link = GetFirstNode (&Private->ThunkContextListHead);
 294   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 295
 296     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
 297     Handle[Count] = ThunkContext->FwHiiHandle;
 298
 299     Count++;
 300     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 301
 302   }
 303
 304   *HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 305   return EFI_SUCCESS;
 306 }
 307
 308 EFI_STATUS
 309 LangCodes3066To639 (
 310   IN CHAR8 *LangCodes3066,
 311   IN CHAR8 **LangCodes639
 312   )
 313 {
 314   CHAR8                      *AsciiLangCodes;
 315   CHAR8                      *Lang;
 316   UINTN                      Index;
 317   UINTN                      Count;
 318   EFI_STATUS                 Status;
 319
 320   ASSERT (LangCodes3066 != NULL);
 321   ASSERT (LangCodes639 != NULL);
 322
 323   //
 324   // Allocate working buffer to contain substring of LangCodes3066.
 325   //
 326   Lang = AllocatePool (AsciiStrSize (LangCodes3066));
 327   if (Lang == NULL) {
 328     return EFI_OUT_OF_RESOURCES;
 329   }
 330
 331   //
 332   // Count the number of RFC 3066 language codes.
 333   //
 334   Index = 0;
 335   AsciiLangCodes = LangCodes3066;
 336   while (AsciiStrLen (AsciiLangCodes) != 0) {
 337     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 338     Index++;
 339   }
 340
 341   Count = Index;
 342
 343   //
 344   //
 345   //
 346   *LangCodes639 = AllocateZeroPool (ISO_639_2_ENTRY_SIZE * Count + 1);
 347   if (*LangCodes639 == NULL) {
 348     Status = EFI_OUT_OF_RESOURCES;
 349     goto Done;
 350   }
 351
 352   AsciiLangCodes = LangCodes3066;
 353
 354   for (Index = 0; Index < Count; Index++) {
 355     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 356     Status = ConvertRfc3066LanguageToIso639Language (Lang, *LangCodes639 + Index * ISO_639_2_ENTRY_SIZE);
 357     ASSERT_EFI_ERROR (Status);
 358   }
 359
 360   Status = EFI_SUCCESS;
 361
 362 Done:
 363   FreePool (Lang);
 364   return Status;
 365 }
 366
 367 /**
 368   Allows a program to determine the primary languages that are supported on a given handle.
 369
 370   This routine is intended to be used by drivers to query the interface database for supported languages.
 371   This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
 372
 373   @param This           A pointer to the EFI_HII_PROTOCOL instance.
 374   @param Handle         The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
 375                         in the Packages section.
 376   @param LanguageString A string allocated by GetPrimaryLanguages() that contains a list of all primary languages
 377                         registered on the handle. The routine will not return the three-spaces language identifier used in
 378                         other functions to indicate non-language-specific strings.
 379
 380   @reval EFI_SUCCESS            LanguageString was correctly returned.
 381
 382   @reval EFI_INVALID_PARAMETER The Handle was unknown.
 383 **/
 384 EFI_STATUS
 385 EFIAPI
 386 HiiGetPrimaryLanguages (
 387   IN  EFI_HII_PROTOCOL            *This,
 388   IN  FRAMEWORK_EFI_HII_HANDLE    Handle,
 389   OUT EFI_STRING                  *LanguageString
 390   )
 391 {
 392   HII_THUNK_PRIVATE_DATA     *Private;
 393   EFI_HII_HANDLE             UefiHiiHandle;
 394   CHAR8                      *LangCodes3066;
 395   CHAR16                     *UnicodeLangCodes639;
 396   CHAR8                      *LangCodes639;
 397   EFI_STATUS                 Status;
 398
 399   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 400
 401   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 402   if (UefiHiiHandle == NULL) {
 403     return EFI_INVALID_PARAMETER;
 404   }
 405
 406   LangCodes3066 = HiiLibGetSupportedLanguages (UefiHiiHandle);
 407
 408   if (LangCodes3066 == NULL) {
 409     return EFI_INVALID_PARAMETER;
 410   }
 411
 412
 413   LangCodes639 = NULL;
 414   Status = LangCodes3066To639 (LangCodes3066, &LangCodes639);
 415   if (EFI_ERROR (Status)) {
 416     goto Done;
 417   }
 418
 419   UnicodeLangCodes639 = AllocateZeroPool (AsciiStrSize (LangCodes639) * sizeof (CHAR16));
 420   if (UnicodeLangCodes639 == NULL) {
 421     Status =  EFI_OUT_OF_RESOURCES;
 422     goto Done;
 423   }
 424
 425   //
 426   // The language returned is in RFC 639-2 format.
 427   //
 428   AsciiStrToUnicodeStr (LangCodes639, UnicodeLangCodes639);
 429   *LanguageString = UnicodeLangCodes639;
 430
 431 Done:
 432   FreePool (LangCodes3066);
 433   if (LangCodes639 != NULL) {
 434     FreePool (LangCodes639);
 435   }
 436
 437   return Status;
 438 }
 439
 440
 441 /**
 442   Allows a program to determine which secondary languages are supported on a given handle for a given primary language
 443
 444   This routine is intended to be used by drivers to query the interface database for supported languages.
 445   This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
 446
 447   @param This           A pointer to the EFI_HII_PROTOCOL instance.
 448   @param Handle         The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
 449                         in the Packages section.
 450   @param PrimaryLanguage Pointer to a NULL-terminated string containing a single ISO 639-2 language identifier, indicating
 451                          the primary language.
 452   @param LanguageString  A string allocated by GetSecondaryLanguages() containing a list of all secondary languages registered
 453                          on the handle. The routine will not return the three-spaces language identifier used in other functions
 454                          to indicate non-language-specific strings, nor will it return the primary language. This function succeeds
 455                          but returns a NULL LanguageString if there are no secondary languages associated with the input Handle and
 456                          PrimaryLanguage pair. Type EFI_STRING is defined in String.
 457
 458   @reval EFI_SUCCESS            LanguageString was correctly returned.
 459   @reval EFI_INVALID_PARAMETER  The Handle was unknown.
 460 **/
 461 EFI_STATUS
 462 EFIAPI
 463 HiiGetSecondaryLanguages (
 464   IN  EFI_HII_PROTOCOL              *This,
 465   IN  FRAMEWORK_EFI_HII_HANDLE      Handle,
 466   IN  CHAR16                        *PrimaryLanguage,
 467   OUT EFI_STRING                    *LanguageString
 468   )
 469 {
 470   HII_THUNK_PRIVATE_DATA     *Private;
 471   EFI_HII_HANDLE             UefiHiiHandle;
 472   CHAR8                      *PrimaryLang3066;
 473   CHAR8                      *PrimaryLang639;
 474   CHAR8                      *SecLangCodes3066;
 475   CHAR8                      *SecLangCodes639;
 476   CHAR16                     *UnicodeSecLangCodes639;
 477   EFI_STATUS                 Status;
 478
 479   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 480
 481   SecLangCodes639        = NULL;
 482   SecLangCodes3066       = NULL;
 483   PrimaryLang3066        = NULL;
 484   UnicodeSecLangCodes639 = NULL;
 485
 486   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 487   if (UefiHiiHandle == NULL) {
 488     return EFI_INVALID_PARAMETER;
 489   }
 490
 491   PrimaryLang639 = AllocateZeroPool (StrLen (PrimaryLanguage) + 1);
 492   if (PrimaryLang639 == NULL) {
 493     Status = EFI_OUT_OF_RESOURCES;
 494     goto Done;
 495   }
 496
 497   UnicodeStrToAsciiStr (PrimaryLanguage, PrimaryLang639);
 498
 499   PrimaryLang3066 = ConvertIso639LanguageToRfc3066Language (PrimaryLang639);
 500   ASSERT_EFI_ERROR (PrimaryLang3066 != NULL);
 501
 502   SecLangCodes3066 = HiiLibGetSupportedSecondaryLanguages (UefiHiiHandle, PrimaryLang3066);
 503
 504   if (SecLangCodes3066 == NULL) {
 505     Status =  EFI_INVALID_PARAMETER;
 506     goto Done;
 507   }
 508
 509   Status = LangCodes3066To639 (SecLangCodes3066, &SecLangCodes639);
 510   if (EFI_ERROR (Status)) {
 511     goto Done;
 512   }
 513
 514   UnicodeSecLangCodes639 = AllocateZeroPool (AsciiStrSize (SecLangCodes639) * sizeof (CHAR16));
 515   if (UnicodeSecLangCodes639 == NULL) {
 516     Status = EFI_OUT_OF_RESOURCES;
 517     goto Done;
 518   }
 519
 520   //
 521   // The language returned is in RFC 3066 format.
 522   //
 523   *LanguageString = AsciiStrToUnicodeStr (SecLangCodes639, UnicodeSecLangCodes639);
 524
 525 Done:
 526   if (PrimaryLang639 != NULL) {
 527     FreePool (PrimaryLang639);
 528   }
 529
 530   if (SecLangCodes639 != NULL) {
 531     FreePool (SecLangCodes639);
 532   }
 533
 534   if (PrimaryLang3066 != NULL) {
 535     FreePool (PrimaryLang3066);
 536   }
 537
 538   if (SecLangCodes3066 != NULL) {
 539     FreePool (SecLangCodes3066);
 540   }
 541   if (UnicodeSecLangCodes639 != NULL) {
 542     FreePool (UnicodeSecLangCodes639);
 543   }
 544
 545   return Status;
 546 }
 547
 548