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     HiiGetString,
  38     HiiResetStrings,
  39     HiiGetLine,
  40     HiiGetForms,
  41     HiiGetDefaultImage,
  42     HiiUpdateForm,
  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[RFC_3066_ENTRY_SIZE];
 316   UINTN                      Index;
 317   UINTN                      Count;
 318   EFI_STATUS                 Status;
 319
 320   ASSERT (LangCodes3066 != NULL);
 321   ASSERT (LangCodes639 != NULL);
 322
 323   //
 324   // Count the number of RFC 3066 language codes.
 325   //
 326   Index = 0;
 327   AsciiLangCodes = LangCodes3066;
 328   while (AsciiStrLen (AsciiLangCodes) != 0) {
 329     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 330     Index++;
 331   }
 332
 333   Count = Index;
 334
 335   //
 336   //
 337   //
 338   *LangCodes639 = AllocateZeroPool (ISO_639_2_ENTRY_SIZE * Count + 1);
 339   if (*LangCodes639 == NULL) {
 340     return EFI_OUT_OF_RESOURCES;
 341   }
 342
 343   AsciiLangCodes = LangCodes3066;
 344
 345   for (Index = 0; Index < Count; Index++) {
 346     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 347     Status = ConvertRfc3066LanguageToIso639Language (Lang, *LangCodes639 + Index * ISO_639_2_ENTRY_SIZE);
 348     ASSERT_EFI_ERROR (Status);
 349   }
 350
 351   return EFI_SUCCESS;
 352 }
 353
 354 /**
 355   Allows a program to determine the primary languages that are supported on a given handle.
 356
 357   This routine is intended to be used by drivers to query the interface database for supported languages.
 358   This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
 359
 360   @param This           A pointer to the EFI_HII_PROTOCOL instance.
 361   @param Handle         The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
 362                         in the Packages section.
 363   @param LanguageString A string allocated by GetPrimaryLanguages() that contains a list of all primary languages
 364                         registered on the handle. The routine will not return the three-spaces language identifier used in
 365                         other functions to indicate non-language-specific strings.
 366
 367   @reval EFI_SUCCESS            LanguageString was correctly returned.
 368
 369   @reval EFI_INVALID_PARAMETER The Handle was unknown.
 370 **/
 371 EFI_STATUS
 372 EFIAPI
 373 HiiGetPrimaryLanguages (
 374   IN  EFI_HII_PROTOCOL            *This,
 375   IN  FRAMEWORK_EFI_HII_HANDLE    Handle,
 376   OUT EFI_STRING                  *LanguageString
 377   )
 378 {
 379   HII_THUNK_PRIVATE_DATA     *Private;
 380   EFI_HII_HANDLE             UefiHiiHandle;
 381   CHAR8                      *LangCodes3066;
 382   CHAR16                     *UnicodeLangCodes639;
 383   CHAR8                      *LangCodes639;
 384   EFI_STATUS                 Status;
 385
 386   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 387
 388   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 389   if (UefiHiiHandle == NULL) {
 390     return EFI_INVALID_PARAMETER;
 391   }
 392
 393   LangCodes3066 = HiiLibGetSupportedLanguages (UefiHiiHandle);
 394
 395   if (LangCodes3066 == NULL) {
 396     return EFI_INVALID_PARAMETER;
 397   }
 398
 399
 400   LangCodes639 = NULL;
 401   Status = LangCodes3066To639 (LangCodes3066, &LangCodes639);
 402   if (EFI_ERROR (Status)) {
 403     goto Done;
 404   }
 405
 406   UnicodeLangCodes639 = AllocateZeroPool (AsciiStrSize (LangCodes639) * sizeof (CHAR16));
 407   if (UnicodeLangCodes639 == NULL) {
 408     Status =  EFI_OUT_OF_RESOURCES;
 409     goto Done;
 410   }
 411
 412   //
 413   // The language returned is in RFC 639-2 format.
 414   //
 415   AsciiStrToUnicodeStr (LangCodes639, UnicodeLangCodes639);
 416   *LanguageString = UnicodeLangCodes639;
 417
 418 Done:
 419   FreePool (LangCodes3066);
 420   if (LangCodes639 != NULL) {
 421     FreePool (LangCodes639);
 422   }
 423
 424   return Status;
 425 }
 426
 427
 428 /**
 429   Allows a program to determine which secondary languages are supported on a given handle for a given primary language
 430
 431   This routine is intended to be used by drivers to query the interface database for supported languages.
 432   This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
 433
 434   @param This           A pointer to the EFI_HII_PROTOCOL instance.
 435   @param Handle         The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
 436                         in the Packages section.
 437   @param PrimaryLanguage Pointer to a NULL-terminated string containing a single ISO 639-2 language identifier, indicating
 438                          the primary language.
 439   @param LanguageString  A string allocated by GetSecondaryLanguages() containing a list of all secondary languages registered
 440                          on the handle. The routine will not return the three-spaces language identifier used in other functions
 441                          to indicate non-language-specific strings, nor will it return the primary language. This function succeeds
 442                          but returns a NULL LanguageString if there are no secondary languages associated with the input Handle and
 443                          PrimaryLanguage pair. Type EFI_STRING is defined in String.
 444
 445   @reval EFI_SUCCESS            LanguageString was correctly returned.
 446   @reval EFI_INVALID_PARAMETER  The Handle was unknown.
 447 **/
 448 EFI_STATUS
 449 EFIAPI
 450 HiiGetSecondaryLanguages (
 451   IN  EFI_HII_PROTOCOL              *This,
 452   IN  FRAMEWORK_EFI_HII_HANDLE      Handle,
 453   IN  CHAR16                        *PrimaryLanguage,
 454   OUT EFI_STRING                    *LanguageString
 455   )
 456 {
 457   HII_THUNK_PRIVATE_DATA *Private;
 458   EFI_HII_HANDLE             UefiHiiHandle;
 459   CHAR8                      PrimaryLang3066[RFC_3066_ENTRY_SIZE];
 460   CHAR8                      *PrimaryLang639;
 461   CHAR8                      *SecLangCodes3066;
 462   CHAR8                      *SecLangCodes639;
 463   CHAR16                     *UnicodeSecLangCodes639;
 464   EFI_STATUS                 Status;
 465
 466   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 467
 468   SecLangCodes639         = NULL;
 469   SecLangCodes3066        = NULL;
 470   UnicodeSecLangCodes639 = NULL;
 471
 472   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 473   if (UefiHiiHandle == NULL) {
 474     return EFI_INVALID_PARAMETER;
 475   }
 476
 477   PrimaryLang639 = AllocateZeroPool (StrLen (PrimaryLanguage) + 1);
 478   if (PrimaryLang639 == NULL) {
 479     Status = EFI_OUT_OF_RESOURCES;
 480     goto Done;
 481   }
 482
 483   UnicodeStrToAsciiStr (PrimaryLanguage, PrimaryLang639);
 484
 485   Status = ConvertIso639LanguageToRfc3066Language (PrimaryLang639, PrimaryLang3066);
 486   ASSERT_EFI_ERROR (Status);
 487
 488   SecLangCodes3066 = HiiLibGetSupportedSecondaryLanguages (UefiHiiHandle, PrimaryLang3066);
 489
 490   if (SecLangCodes3066 == NULL) {
 491     Status =  EFI_INVALID_PARAMETER;
 492     goto Done;
 493   }
 494
 495   Status = LangCodes3066To639 (SecLangCodes3066, &SecLangCodes639);
 496   if (EFI_ERROR (Status)) {
 497     goto Done;
 498   }
 499
 500   UnicodeSecLangCodes639 = AllocateZeroPool (AsciiStrSize (SecLangCodes639) * sizeof (CHAR16));
 501   if (UnicodeSecLangCodes639 == NULL) {
 502     Status = EFI_OUT_OF_RESOURCES;
 503     goto Done;
 504   }
 505
 506   //
 507   // The language returned is in RFC 3066 format.
 508   //
 509   *LanguageString = AsciiStrToUnicodeStr (SecLangCodes639, UnicodeSecLangCodes639);
 510
 511 Done:
 512   if (PrimaryLang639 != NULL) {
 513     FreePool (PrimaryLang639);
 514   }
 515   if (SecLangCodes639 != NULL) {
 516     FreePool (SecLangCodes639);
 517   }
 518   if (SecLangCodes3066 != NULL) {
 519     FreePool (SecLangCodes3066);
 520   }
 521   if (UnicodeSecLangCodes639 != NULL) {
 522     FreePool (UnicodeSecLangCodes639);
 523   }
 524
 525   return Status;
 526 }
 527
 528