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 HII_THUNK_PRIVATE_DATA *mHiiThunkPrivateData;
  19
  20 HII_THUNK_PRIVATE_DATA mHiiThunkPrivateDataTempate = {
  21   HII_THUNK_PRIVATE_DATA_SIGNATURE,
  22   (EFI_HANDLE) NULL,
  23   {
  24     HiiNewPack,
  25     HiiRemovePack,
  26     HiiFindHandles,
  27     HiiExportDatabase,
  28
  29     HiiTestString,
  30     HiiGetGlyph,
  31     HiiGlyphToBlt,
  32
  33     HiiNewString,
  34     HiiGetPrimaryLanguages,
  35     HiiGetSecondaryLanguages,
  36     HiiGetString,
  37     HiiResetStrings,
  38     HiiGetLine,
  39     HiiGetForms,
  40     HiiGetDefaultImage,
  41     HiiUpdateForm,
  42
  43     HiiGetKeyboardLayout
  44   },
  45
  46   //
  47   //StaticHiiHandle
  48   //The FRAMEWORK_EFI_HII_HANDLE starts from 1
  49   // and increase upwords untill reach the value of StaticPureUefiHiiHandle.
  50   // The code will assert to prevent overflow.
  51   (FRAMEWORK_EFI_HII_HANDLE) 1,
  52
  53   //
  54   //StaticPureUefiHiiHandle
  55   //The Static FRAMEWORK_EFI_HII_HANDLE starts from 0xFFFF
  56   // and decrease downwords untill reach the value of StaticHiiHandle.
  57   // The code will assert to prevent overflow.
  58   //
  59   (FRAMEWORK_EFI_HII_HANDLE) 0xFFFF,
  60   {
  61     NULL, NULL                  //HiiHandleLinkList
  62   },
  63 };
  64
  65 EFI_FORMBROWSER_THUNK_PRIVATE_DATA mBrowserThunkPrivateDataTemplate = {
  66   EFI_FORMBROWSER_THUNK_PRIVATE_DATA_SIGNATURE,
  67   (EFI_HANDLE) NULL,
  68   (HII_THUNK_PRIVATE_DATA *) NULL,
  69   {
  70     ThunkSendForm,
  71     ThunkCreatePopUp
  72   }
  73 };
  74
  75
  76 CONST EFI_HII_DATABASE_PROTOCOL            *mHiiDatabase;
  77 CONST EFI_HII_IMAGE_PROTOCOL               *mHiiImageProtocol;
  78 CONST EFI_HII_STRING_PROTOCOL              *mHiiStringProtocol;
  79 CONST EFI_HII_FONT_PROTOCOL                *mHiiFontProtocol;
  80 CONST EFI_HII_CONFIG_ROUTING_PROTOCOL      *mHiiConfigRoutingProtocol;
  81 CONST EFI_FORM_BROWSER2_PROTOCOL           *mFormBrowser2Protocol;
  82
  83
  84
  85
  86
  87
  88 EFI_STATUS
  89 EFIAPI
  90 InitializeHiiDatabase (
  91   IN EFI_HANDLE           ImageHandle,
  92   IN EFI_SYSTEM_TABLE     *SystemTable
  93   )
  94 /*++
  95
  96 Routine Description:
  97   Initialize HII Database
  98
  99 Arguments:
 100   (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
 101
 102 Returns:
 103   EFI_SUCCESS - Setup loaded.
 104   other       - Setup Error
 105
 106 --*/
 107 {
 108   HII_THUNK_PRIVATE_DATA *Private;
 109   EFI_HANDLE              Handle;
 110   EFI_STATUS              Status;
 111   UINTN                   BufferLength;
 112   EFI_HII_HANDLE          *Buffer;
 113   UINTN                   Index;
 114
 115
 116   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiHiiProtocolGuid);
 117
 118   Private = AllocateCopyPool (sizeof (HII_THUNK_PRIVATE_DATA), &mHiiThunkPrivateDataTempate);
 119   ASSERT (Private != NULL);
 120   InitializeListHead (&Private->ThunkContextListHead);
 121
 122   mHiiThunkPrivateData = Private;
 123
 124   Status = gBS->LocateProtocol (
 125                   &gEfiHiiDatabaseProtocolGuid,
 126                   NULL,
 127                   (VOID **) &mHiiDatabase
 128                   );
 129   ASSERT_EFI_ERROR (Status);
 130
 131   Status = gBS->LocateProtocol (
 132                   &gEfiHiiStringProtocolGuid,
 133                   NULL,
 134                   (VOID **) &mHiiStringProtocol
 135                   );
 136   ASSERT_EFI_ERROR (Status);
 137
 138   Status = gBS->LocateProtocol (
 139                   &gEfiHiiFontProtocolGuid,
 140                   NULL,
 141                   (VOID **) &mHiiFontProtocol
 142                   );
 143   ASSERT_EFI_ERROR (Status);
 144
 145   Status = gBS->LocateProtocol (
 146                   &gEfiHiiConfigRoutingProtocolGuid,
 147                   NULL,
 148                   (VOID **) &mHiiConfigRoutingProtocol
 149                   );
 150   ASSERT_EFI_ERROR (Status);
 151
 152
 153   Status = gBS->LocateProtocol (
 154                   &gEfiFormBrowser2ProtocolGuid,
 155                   NULL,
 156                   (VOID **) &mFormBrowser2Protocol
 157                   );
 158   ASSERT_EFI_ERROR (Status);
 159
 160
 161
 162
 163   //
 164   // Install protocol interface
 165   //
 166   Status = gBS->InstallProtocolInterface (
 167                   &Private->Handle,
 168                   &gEfiHiiProtocolGuid,
 169                   EFI_NATIVE_INTERFACE,
 170                   (VOID *) &Private->Hii
 171                   );
 172   ASSERT_EFI_ERROR (Status);
 173
 174   Status = HiiLibListPackageLists (EFI_HII_PACKAGE_STRINGS, NULL, &BufferLength, &Buffer);
 175   if (Status == EFI_SUCCESS) {
 176     for (Index = 0; Index < BufferLength / sizeof (EFI_HII_HANDLE); Index++) {
 177       CreateThunkContextForUefiHiiHandle (Private, Buffer[Index]);
 178       ASSERT_EFI_ERROR (Status);
 179     }
 180
 181     FreePool (Buffer);
 182   }
 183
 184   Status = mHiiDatabase->RegisterPackageNotify (
 185                            mHiiDatabase,
 186                            EFI_HII_PACKAGE_STRINGS,
 187                            NULL,
 188                            NewOrAddPackNotify,
 189                            EFI_HII_DATABASE_NOTIFY_NEW_PACK,
 190                            &Handle
 191                            );
 192   ASSERT_EFI_ERROR (Status);
 193
 194   Status = mHiiDatabase->RegisterPackageNotify (
 195                            mHiiDatabase,
 196                            EFI_HII_PACKAGE_STRINGS,
 197                            NULL,
 198                            NewOrAddPackNotify,
 199                            EFI_HII_DATABASE_NOTIFY_ADD_PACK,
 200                            &Handle
 201                            );
 202   ASSERT_EFI_ERROR (Status);
 203
 204   Status = mHiiDatabase->RegisterPackageNotify (
 205                            mHiiDatabase,
 206                            EFI_HII_PACKAGE_FORM,
 207                            NULL,
 208                            NewOrAddPackNotify,
 209                            EFI_HII_DATABASE_NOTIFY_NEW_PACK,
 210                            &Handle
 211                            );
 212   ASSERT_EFI_ERROR (Status);
 213
 214   Status = mHiiDatabase->RegisterPackageNotify (
 215                            mHiiDatabase,
 216                            EFI_HII_PACKAGE_FORM,
 217                            NULL,
 218                            NewOrAddPackNotify,
 219                            EFI_HII_DATABASE_NOTIFY_ADD_PACK,
 220                            &Handle
 221                            );
 222   ASSERT_EFI_ERROR (Status);
 223
 224   Status = mHiiDatabase->RegisterPackageNotify (
 225                            mHiiDatabase,
 226                            EFI_HII_PACKAGE_STRINGS,
 227                            NULL,
 228                            RemovePackNotify,
 229                            EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
 230                            &Handle
 231                            );
 232   ASSERT_EFI_ERROR (Status);
 233
 234   mBrowserThunkPrivateDataTemplate.ThunkPrivate = Private;
 235   Status = gBS->InstallProtocolInterface (
 236                   &mBrowserThunkPrivateDataTemplate.Handle,
 237                   &gEfiFormBrowserProtocolGuid,
 238                   EFI_NATIVE_INTERFACE,
 239                   (VOID *) &mBrowserThunkPrivateDataTemplate.FormBrowser
 240                   );
 241   ASSERT_EFI_ERROR (Status);
 242
 243   return Status;
 244 }
 245
 246 EFI_STATUS
 247 EFIAPI
 248 HiiFindHandles (
 249   IN     EFI_HII_PROTOCOL *This,
 250   IN OUT UINT16           *HandleBufferLength,
 251   OUT    FRAMEWORK_EFI_HII_HANDLE    Handle[1]
 252   )
 253 /*++
 254
 255 Routine Description:
 256   Determines the handles that are currently active in the database.
 257
 258 Arguments:
 259
 260 Returns:
 261
 262 --*/
 263 {
 264   UINT16                                     Count;
 265   LIST_ENTRY                                *Link;
 266   HII_THUNK_CONTEXT *ThunkContext;
 267   HII_THUNK_PRIVATE_DATA               *Private;
 268
 269   if (HandleBufferLength == NULL) {
 270     return EFI_INVALID_PARAMETER;
 271   }
 272
 273   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 274
 275   //
 276   // Count the number of handles.
 277   //
 278   Count = 0;
 279   Link = GetFirstNode (&Private->ThunkContextListHead);
 280   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 281     Count++;
 282     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 283   }
 284
 285   if (Count > *HandleBufferLength) {
 286     *HandleBufferLength = (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 287     return EFI_BUFFER_TOO_SMALL;
 288   }
 289
 290   //
 291   // Output the handles.
 292   //
 293   Count = 0;
 294   Link = GetFirstNode (&Private->ThunkContextListHead);
 295   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 296
 297     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
 298     Handle[Count] = ThunkContext->FwHiiHandle;
 299
 300     Count++;
 301     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 302
 303   }
 304
 305   *HandleBufferLength = (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
 306   return EFI_SUCCESS;
 307 }
 308
 309 EFI_STATUS
 310 LangCodes3066To639 (
 311   IN CHAR8 *LangCodes3066,
 312   IN CHAR8 **LangCodes639
 313   )
 314 {
 315   CHAR8                      *AsciiLangCodes;
 316   CHAR8                      Lang[RFC_3066_ENTRY_SIZE];
 317   UINTN                      Index;
 318   UINTN                      Count;
 319   EFI_STATUS                 Status;
 320
 321   ASSERT (LangCodes3066 != NULL);
 322   ASSERT (LangCodes639 != NULL);
 323
 324   //
 325   // Count the number of RFC 3066 language codes.
 326   //
 327   Index = 0;
 328   AsciiLangCodes = LangCodes3066;
 329   while (AsciiStrLen (AsciiLangCodes) != 0) {
 330     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 331     Index++;
 332   }
 333
 334   Count = Index;
 335
 336   //
 337   //
 338   //
 339   *LangCodes639 = AllocateZeroPool (ISO_639_2_ENTRY_SIZE * Count + 1);
 340   if (*LangCodes639 == NULL) {
 341     return EFI_OUT_OF_RESOURCES;
 342   }
 343
 344   AsciiLangCodes = LangCodes3066;
 345
 346   for (Index = 0; Index < Count; Index++) {
 347     HiiLibGetNextLanguage (&AsciiLangCodes, Lang);
 348     Status = ConvertRfc3066LanguageToIso639Language (Lang, *LangCodes639 + Index * ISO_639_2_ENTRY_SIZE);
 349     ASSERT_EFI_ERROR (Status);
 350   }
 351
 352   return EFI_SUCCESS;
 353 }
 354
 355 EFI_STATUS
 356 EFIAPI
 357 HiiGetPrimaryLanguages (
 358   IN  EFI_HII_PROTOCOL      *This,
 359   IN  FRAMEWORK_EFI_HII_HANDLE         Handle,
 360   OUT EFI_STRING            *LanguageString
 361   )
 362 /*++
 363
 364 Routine Description:
 365
 366   This function allows a program to determine what the primary languages that are supported on a given handle.
 367
 368 Arguments:
 369
 370 Returns:
 371
 372 --*/
 373 {
 374   HII_THUNK_PRIVATE_DATA     *Private;
 375   EFI_HII_HANDLE             UefiHiiHandle;
 376   CHAR8                      *LangCodes3066;
 377   CHAR16                     *UnicodeLangCodes639;
 378   CHAR8                      *LangCodes639;
 379   EFI_STATUS                 Status;
 380
 381   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 382
 383   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 384   if (UefiHiiHandle == NULL) {
 385     return EFI_INVALID_PARAMETER;
 386   }
 387
 388   LangCodes3066 = HiiLibGetSupportedLanguages (UefiHiiHandle);
 389
 390   if (LangCodes3066 == NULL) {
 391     return EFI_INVALID_PARAMETER;
 392   }
 393
 394
 395   LangCodes639 = NULL;
 396   Status = LangCodes3066To639 (LangCodes3066, &LangCodes639);
 397   if (EFI_ERROR (Status)) {
 398     goto Done;
 399   }
 400
 401   UnicodeLangCodes639 = AllocateZeroPool (AsciiStrSize (LangCodes639) * sizeof (CHAR16));
 402   if (UnicodeLangCodes639 == NULL) {
 403     Status =  EFI_OUT_OF_RESOURCES;
 404     goto Done;
 405   }
 406
 407   //
 408   // The language returned is in RFC 639-2 format.
 409   //
 410   AsciiStrToUnicodeStr (LangCodes639, UnicodeLangCodes639);
 411   *LanguageString = UnicodeLangCodes639;
 412
 413 Done:
 414   FreePool (LangCodes3066);
 415   SafeFreePool (LangCodes639);
 416
 417   return Status;
 418 }
 419
 420
 421
 422 EFI_STATUS
 423 EFIAPI
 424 HiiGetSecondaryLanguages (
 425   IN  EFI_HII_PROTOCOL              *This,
 426   IN  FRAMEWORK_EFI_HII_HANDLE      Handle,
 427   IN  CHAR16                        *PrimaryLanguage,
 428   OUT EFI_STRING                    *LanguageString
 429   )
 430 /*++
 431
 432 Routine Description:
 433
 434   This function allows a program to determine which secondary languages are supported
 435   on a given handle for a given primary language.
 436
 437   Arguments:
 438
 439 Returns:
 440
 441 --*/
 442 {
 443   HII_THUNK_PRIVATE_DATA *Private;
 444   EFI_HII_HANDLE             UefiHiiHandle;
 445   CHAR8                      PrimaryLang3066[RFC_3066_ENTRY_SIZE];
 446   CHAR8                      *PrimaryLang639;
 447   CHAR8                      *SecLangCodes3066;
 448   CHAR8                      *SecLangCodes639;
 449   CHAR16                     *UnicodeSecLangCodes639;
 450   EFI_STATUS                 Status;
 451
 452   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 453
 454   SecLangCodes639         = NULL;
 455   SecLangCodes3066        = NULL;
 456   UnicodeSecLangCodes639 = NULL;
 457
 458   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 459   if (UefiHiiHandle == NULL) {
 460     return EFI_INVALID_PARAMETER;
 461   }
 462
 463   PrimaryLang639 = AllocateZeroPool (StrLen (PrimaryLanguage) + 1);
 464   if (PrimaryLang639 == NULL) {
 465     Status = EFI_OUT_OF_RESOURCES;
 466     goto Done;
 467   }
 468
 469   UnicodeStrToAsciiStr (PrimaryLanguage, PrimaryLang639);
 470
 471   Status = ConvertIso639LanguageToRfc3066Language (PrimaryLang639, PrimaryLang3066);
 472   ASSERT_EFI_ERROR (Status);
 473
 474   SecLangCodes3066 = HiiLibGetSupportedSecondaryLanguages (UefiHiiHandle, PrimaryLang3066);
 475
 476   if (SecLangCodes3066 == NULL) {
 477     Status =  EFI_INVALID_PARAMETER;
 478     goto Done;
 479   }
 480
 481   Status = LangCodes3066To639 (SecLangCodes3066, &SecLangCodes639);
 482   if (EFI_ERROR (Status)) {
 483     goto Done;
 484   }
 485
 486   UnicodeSecLangCodes639 = AllocateZeroPool (AsciiStrSize (SecLangCodes639) * sizeof (CHAR16));
 487   if (UnicodeSecLangCodes639 == NULL) {
 488     Status = EFI_OUT_OF_RESOURCES;
 489     goto Done;
 490   }
 491
 492   //
 493   // The language returned is in RFC 3066 format.
 494   //
 495   *LanguageString = AsciiStrToUnicodeStr (SecLangCodes639, UnicodeSecLangCodes639);
 496
 497 Done:
 498
 499   SafeFreePool (PrimaryLang639);
 500   SafeFreePool (SecLangCodes639);
 501   SafeFreePool (SecLangCodes3066);
 502   SafeFreePool (UnicodeSecLangCodes639);
 503
 504   return Status;
 505 }
 506
 507