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