MdeModulePkg/VarCheckHii: Enhance VarCheckHiiLib to support bit check

V3:
(1) Reset QuestionStoredInBitField to FALSE at end opcode(EFI_IFR_END_OP)
(2) Fix typo and format issues(line alignment for debug print message
and value assignment...)

V2:
(1)Remove the VarOffsetBitLevel/StorageWidthBitLevel to reduce the final
VarCheckBinSize and update the implementation accordingly.
(2)Update the VAR_CHECK_HII_REVISION
(3)Refine the Debug message and function comments,like update oneof",
"checkbox", "numeric" to "OneOf", "CheckBox", "Numeric".

VarCheckHiiLib check the value set to storage based on the possible value
listed in the vfr file. Since we have enhanced vfr to support Question
value stored in bit field, so now enhance VarCheckHiiLib to support bit
field check.

Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Dandan Bi <dandan.bi@intel.com>
Reviewed-by: Star Zeng <star.zeng@intel.com>

diff --git a/MdeModulePkg/Library/VarCheckHiiLib/InternalVarCheckStructure.h b/MdeModulePkg/Library/VarCheckHiiLib/InternalVarCheckStructure.h
index a9faed48d9600d4b636ba1ae00578f4e08c15b73..8878e4aef84ae608b260db49b182257b13f0f4db 100644 (file)
--- a/MdeModulePkg/Library/VarCheckHiiLib/InternalVarCheckStructure.h
+++ b/MdeModulePkg/Library/VarCheckHiiLib/InternalVarCheckStructure.h
@@ -1,7 +1,7 @@
 /** @file\r
   Internal structure for Var Check Hii.\r
 \r
-Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
 This program and the accompanying materials\r
 are licensed and made available under the terms and conditions of the BSD License\r
 which accompanies this distribution.  The full text of the license may be found at\r
@@ -23,7 +23,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 \r
 #pragma pack (1)\r
 \r
-#define VAR_CHECK_HII_REVISION  0x0001\r
+#define VAR_CHECK_HII_REVISION  0x0002\r
 \r
 typedef struct {\r
   UINT16            Revision;\r
@@ -42,6 +42,7 @@ typedef struct {
   UINT8             Length; // Length include this header\r
   UINT16            VarOffset;\r
   UINT8             StorageWidth;\r
+  BOOLEAN           BitFieldStore; // Whether the Question is stored in bit field, if TRUE, the VarOffset/StorageWidth will be saved as bit level, otherwise in byte level.\r
 } VAR_CHECK_HII_QUESTION_HEADER;\r
 \r
 typedef struct {\r
@@ -49,6 +50,7 @@ typedef struct {
   UINT8             Length; // Length include this header\r
   UINT16            VarOffset;\r
   UINT8             StorageWidth;\r
+  BOOLEAN           BitFieldStore; // Whether the Question is stored in bit field, if TRUE, the VarOffset/StorageWidth will be saved as bit level, otherwise in byte level.\r
 //UINTx               Data[]; // x = UINT8/UINT16/UINT32/UINT64;\r
 } VAR_CHECK_HII_QUESTION_ONEOF;\r
 \r
@@ -57,6 +59,7 @@ typedef struct {
   UINT8             Length; // Length include this header\r
   UINT16            VarOffset;\r
   UINT8             StorageWidth;\r
+  BOOLEAN           BitFieldStore; // Whether the Question is stored in bit field, if TRUE, the VarOffset/StorageWidth will be saved as bit level, otherwise in byte level.\r
 } VAR_CHECK_HII_QUESTION_CHECKBOX;\r
 \r
 typedef struct {\r
@@ -64,6 +67,7 @@ typedef struct {
   UINT8             Length; // Length include this header\r
   UINT16            VarOffset;\r
   UINT8             StorageWidth;\r
+  BOOLEAN           BitFieldStore; // Whether the Question is stored in bit field, if TRUE, the VarOffset/StorageWidth will be saved as bit level, otherwise in byte level.\r
 //UINTx               Minimum; // x = UINT8/UINT16/UINT32/UINT64;\r
 //UINTx               Maximum; // x = UINT8/UINT16/UINT32/UINT64;\r
 } VAR_CHECK_HII_QUESTION_NUMERIC;\r
@@ -73,6 +77,7 @@ typedef struct {
   UINT8             Length; // Length include this header\r
   UINT16            VarOffset;\r
   UINT8             StorageWidth;\r
+  BOOLEAN           BitFieldStore; // Whether the Question is stored in bit field, if TRUE, the VarOffset/StorageWidth will be saved as bit level, otherwise in byte level.\r
   UINT8             MaxContainers;\r
 //UINTx               Data[]; // x = UINT8/UINT16/UINT32/UINT64;\r
 } VAR_CHECK_HII_QUESTION_ORDEREDLIST;\r

diff --git a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHii.h b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHii.h
index a54b867983b55aea0a1b7fd23237a5b41a1c2b8a..7363edf028a6a8c35f07b487eddd6b0beed25c6c 100644 (file)
--- a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHii.h
+++ b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHii.h
@@ -1,7 +1,7 @@
 /** @file\r
   Include file for Var Check Hii handler and bin.\r
 \r
-Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
 This program and the accompanying materials\r
 are licensed and made available under the terms and conditions of the BSD License\r
 which accompanies this distribution.  The full text of the license may be found at\r
@@ -22,6 +22,8 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <Library/UefiBootServicesTableLib.h>\r
 #include <Library/MemoryAllocationLib.h>\r
 \r
+#include <Guid/MdeModuleHii.h>\r
+\r
 #include <Protocol/HiiDatabase.h>\r
 #include <Protocol/FirmwareVolume2.h>\r
 #include <Protocol/FirmwareVolumeBlock.h>\r

diff --git a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGen.c b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGen.c
index 0e91e982190a6d501503caee3dfc71e8d9c66e8d..c0efed450bfbf861da9d2fa61d925e0154c75ea9 100644 (file)
--- a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGen.c
+++ b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGen.c
@@ -1,7 +1,7 @@
 /** @file\r
   Var Check Hii bin generation.\r
 \r
-Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
 This program and the accompanying materials\r
 are licensed and made available under the terms and conditions of the BSD License\r
 which accompanies this distribution.  The full text of the license may be found at\r
@@ -120,8 +120,10 @@ DumpHiiPackage (
   EFI_IFR_OP_HEADER             *IfrOpCodeHeader;\r
   EFI_IFR_VARSTORE              *IfrVarStore;\r
   EFI_IFR_VARSTORE_EFI          *IfrEfiVarStore;\r
+  BOOLEAN                       QuestionStoredInBitField;\r
 \r
   HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiPackage;\r
+  QuestionStoredInBitField = FALSE;\r
 \r
   DEBUG ((DEBUG_INFO, "  HiiPackageHeader->Type   - 0x%02x (%a)\n", HiiPackageHeader->Type, HiiPackageTypeToStr ((UINT8) HiiPackageHeader->Type)));\r
   DEBUG ((DEBUG_INFO, "  HiiPackageHeader->Length - 0x%06x\n", HiiPackageHeader->Length));\r
@@ -157,18 +159,24 @@ DumpHiiPackage (
             }\r
             break;\r
 \r
+          case EFI_IFR_GUID_OP:\r
+            if (CompareGuid ((EFI_GUID *)((UINTN)IfrOpCodeHeader + sizeof (EFI_IFR_OP_HEADER)), &gEdkiiIfrBitVarstoreGuid)) {\r
+              QuestionStoredInBitField = TRUE;\r
+            }\r
+            break;\r
+\r
           case EFI_IFR_ONE_OF_OP:\r
           case EFI_IFR_CHECKBOX_OP:\r
           case EFI_IFR_NUMERIC_OP:\r
           case EFI_IFR_ORDERED_LIST_OP:\r
-            DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->OpCode - 0x%02x (%a)\n", IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode)));\r
+            DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->OpCode - 0x%02x (%a) (%a)\n", IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode), (QuestionStoredInBitField? "bit level": "byte level")));\r
             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Length - 0x%02x\n", IfrOpCodeHeader->Length));\r
             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Scope  - 0x%02x\n", IfrOpCodeHeader->Scope));\r
             DEBUG ((DEBUG_INFO, "      Prompt       - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Prompt));\r
             DEBUG ((DEBUG_INFO, "      Help         - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Help));\r
             DEBUG ((DEBUG_INFO, "      QuestionId   - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.QuestionId));\r
             DEBUG ((DEBUG_INFO, "      VarStoreId   - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.VarStoreId));\r
-            DEBUG ((DEBUG_INFO, "      VarStoreInfo - 0x%04x\n", ((EFI_IFR_ONE_OF * )IfrOpCodeHeader)->Question.VarStoreInfo.VarOffset));\r
+            DEBUG ((DEBUG_INFO, "      VarStoreInfo - 0x%04x (%a)\n", ((EFI_IFR_ONE_OF * )IfrOpCodeHeader)->Question.VarStoreInfo.VarOffset, (QuestionStoredInBitField? "bit level": "byte level")));\r
             {\r
               EFI_IFR_ONE_OF            *IfrOneOf;\r
               EFI_IFR_CHECKBOX          *IfrCheckBox;\r
@@ -179,27 +187,36 @@ DumpHiiPackage (
                 case EFI_IFR_ONE_OF_OP:\r
                   IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpCodeHeader;\r
                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrOneOf->Flags));\r
-                  switch (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE) {\r
-                  case EFI_IFR_NUMERIC_SIZE_1:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrOneOf->data.u8.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrOneOf->data.u8.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrOneOf->data.u8.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_2:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrOneOf->data.u16.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrOneOf->data.u16.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrOneOf->data.u16.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_4:\r
+                  if (QuestionStoredInBitField) {\r
+                    //\r
+                    // For OneOf stored in bit field, the option value are saved as UINT32 type.\r
+                    //\r
                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrOneOf->data.u32.MinValue));\r
                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrOneOf->data.u32.MaxValue));\r
                     DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrOneOf->data.u32.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_8:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrOneOf->data.u64.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrOneOf->data.u64.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrOneOf->data.u64.Step));\r
-                    break;\r
+                  } else {\r
+                    switch (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE) {\r
+                    case EFI_IFR_NUMERIC_SIZE_1:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrOneOf->data.u8.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrOneOf->data.u8.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrOneOf->data.u8.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_2:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrOneOf->data.u16.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrOneOf->data.u16.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrOneOf->data.u16.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_4:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrOneOf->data.u32.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrOneOf->data.u32.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrOneOf->data.u32.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_8:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrOneOf->data.u64.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrOneOf->data.u64.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrOneOf->data.u64.Step));\r
+                      break;\r
+                    }\r
                   }\r
                   break;\r
                 case EFI_IFR_CHECKBOX_OP:\r
@@ -209,27 +226,36 @@ DumpHiiPackage (
                 case EFI_IFR_NUMERIC_OP:\r
                   IfrNumeric = (EFI_IFR_NUMERIC *) IfrOpCodeHeader;\r
                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrNumeric->Flags));\r
-                  switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) {\r
-                  case EFI_IFR_NUMERIC_SIZE_1:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrNumeric->data.u8.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrNumeric->data.u8.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrNumeric->data.u8.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_2:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrNumeric->data.u16.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrNumeric->data.u16.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrNumeric->data.u16.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_4:\r
+                  if (QuestionStoredInBitField) {\r
+                    //\r
+                    // For Numeric stored in bit field, the MinValue,MaxValue and Step are saved as UINT32 type.\r
+                    //\r
                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrNumeric->data.u32.MinValue));\r
                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrNumeric->data.u32.MaxValue));\r
                     DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrNumeric->data.u32.Step));\r
-                    break;\r
-                  case EFI_IFR_NUMERIC_SIZE_8:\r
-                    DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrNumeric->data.u64.MinValue));\r
-                    DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrNumeric->data.u64.MaxValue));\r
-                    DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrNumeric->data.u64.Step));\r
-                    break;\r
+                  } else {\r
+                    switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) {\r
+                    case EFI_IFR_NUMERIC_SIZE_1:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrNumeric->data.u8.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrNumeric->data.u8.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrNumeric->data.u8.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_2:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrNumeric->data.u16.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrNumeric->data.u16.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrNumeric->data.u16.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_4:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrNumeric->data.u32.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrNumeric->data.u32.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrNumeric->data.u32.Step));\r
+                      break;\r
+                    case EFI_IFR_NUMERIC_SIZE_8:\r
+                      DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrNumeric->data.u64.MinValue));\r
+                      DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrNumeric->data.u64.MaxValue));\r
+                      DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrNumeric->data.u64.Step));\r
+                      break;\r
+                    }\r
                   }\r
                   break;\r
                 case EFI_IFR_ORDERED_LIST_OP:\r
@@ -279,6 +305,7 @@ DumpHiiPackage (
                   }\r
 \r
                   if (IfrOpCodeHeader->OpCode == EFI_IFR_END_OP) {\r
+                    QuestionStoredInBitField = FALSE;\r
                     ASSERT (Scope > 0);\r
                     Scope--;\r
                     if (Scope == 0) {\r
@@ -488,6 +515,7 @@ MergeHiiQuestion (
   UINT8                             *Ptr;\r
   UINT8                             *Ptr1;\r
   UINT8                             *Ptr2;\r
+  UINT16                            ArrayIndex;\r
 \r
   //\r
   // Hii Question from Hii Database has high priority.\r
@@ -498,14 +526,20 @@ MergeHiiQuestion (
     return;\r
   }\r
 \r
-  HiiQuestion1 = HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset];\r
+  if (HiiQuestion->BitFieldStore) {\r
+    ArrayIndex = HiiQuestion->VarOffset;\r
+  } else {\r
+    ArrayIndex = HiiQuestion->VarOffset * 8;\r
+  }\r
+\r
+  HiiQuestion1 = HiiVariableNode->HiiQuestionArray[ArrayIndex];\r
   HiiQuestion2 = HiiQuestion;\r
 \r
   ASSERT ((HiiQuestion1->OpCode == HiiQuestion2->OpCode) && (HiiQuestion1->StorageWidth == HiiQuestion2->StorageWidth));\r
 \r
   switch (HiiQuestion1->OpCode) {\r
     case EFI_IFR_ONE_OF_OP:\r
-      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_ONE_OF_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));\r
+      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_ONE_OF_OP VarOffset = 0x%04x (%a)\n", HiiQuestion1->VarOffset, (HiiQuestion1->BitFieldStore? "bit level": "byte level")));\r
       //\r
       // Get the length of Hii Question 1.\r
       //\r
@@ -580,17 +614,17 @@ MergeHiiQuestion (
           Ptr2 += HiiQuestion2->StorageWidth;\r
         }\r
 \r
-        HiiVariableNode->HiiQuestionArray[HiiQuestion1->VarOffset] = NewHiiQuestion;\r
+        HiiVariableNode->HiiQuestionArray[ArrayIndex] = NewHiiQuestion;\r
         InternalVarCheckFreePool (HiiQuestion1);\r
       }\r
       break;\r
 \r
     case EFI_IFR_CHECKBOX_OP:\r
-      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_CHECKBOX_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));\r
+      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_CHECKBOX_OP VarOffset = 0x%04x (%a)\n", HiiQuestion1->VarOffset, (HiiQuestion1->BitFieldStore? "bit level": "byte level")));\r
       break;\r
 \r
     case EFI_IFR_NUMERIC_OP:\r
-      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_NUMERIC_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));\r
+      DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_NUMERIC_OP VarOffset = 0x%04x (%a)\n", HiiQuestion1->VarOffset, (HiiQuestion1->BitFieldStore? "bit level": "byte level")));\r
       //\r
       // Get minimum and maximum of Hii Question 1.\r
       //\r
@@ -705,7 +739,7 @@ MergeHiiQuestion (
           Ptr2 += HiiQuestion2->StorageWidth;\r
         }\r
 \r
-        HiiVariableNode->HiiQuestionArray[HiiQuestion1->VarOffset] = NewHiiQuestion;\r
+        HiiVariableNode->HiiQuestionArray[ArrayIndex] = NewHiiQuestion;\r
         InternalVarCheckFreePool (HiiQuestion1);\r
       }\r
       break;\r
@@ -831,13 +865,15 @@ GetOneOfOption (
   Parse Hii Question Oneof.\r
 \r
   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.\r
+  @param[in] StoredInBitField   Whether the OneOf is stored in bit field Storage.\r
 \r
   return Pointer to Hii Question.\r
 \r
 **/\r
 VAR_CHECK_HII_QUESTION_HEADER *\r
 ParseHiiQuestionOneOf (\r
-  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader\r
+  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader,\r
+  IN BOOLEAN            StoredInBitField\r
   )\r
 {\r
   EFI_IFR_ONE_OF                *IfrOneOf;\r
@@ -846,10 +882,21 @@ ParseHiiQuestionOneOf (
   UINT8                         Width;\r
   UINTN                         OptionCount;\r
   UINT8                         OptionWidth;\r
+  UINT8                         BitWidth;\r
 \r
   IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpCodeHeader;\r
+  BitWidth = 0;\r
 \r
-  Width = (UINT8) (1 << (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE));\r
+  if (StoredInBitField) {\r
+    //\r
+    // When OneOf stored in bit field, the bit width is saved in the lower six bits of the flag.\r
+    // And the options in the OneOf is saved as UINT32 type.\r
+    //\r
+    BitWidth = IfrOneOf->Flags & EDKII_IFR_NUMERIC_SIZE_BIT;\r
+    Width = sizeof (UINT32);\r
+  } else {\r
+    Width = (UINT8) (1 << (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE));\r
+  }\r
 \r
   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, NULL);\r
   ASSERT (Width == OptionWidth);\r
@@ -858,10 +905,15 @@ ParseHiiQuestionOneOf (
 \r
   OneOf = InternalVarCheckAllocateZeroPool (Length);\r
   ASSERT (OneOf != NULL);\r
-  OneOf->OpCode       = EFI_IFR_ONE_OF_OP;\r
-  OneOf->Length       = (UINT8) Length;\r
-  OneOf->VarOffset    = IfrOneOf->Question.VarStoreInfo.VarOffset;\r
-  OneOf->StorageWidth = Width;\r
+  OneOf->OpCode         = EFI_IFR_ONE_OF_OP;\r
+  OneOf->Length         = (UINT8) Length;\r
+  OneOf->VarOffset      = IfrOneOf->Question.VarStoreInfo.VarOffset;\r
+  OneOf->BitFieldStore  = StoredInBitField;\r
+  if (StoredInBitField) {\r
+    OneOf->StorageWidth = BitWidth;\r
+  } else {\r
+    OneOf->StorageWidth = Width;\r
+  }\r
 \r
   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, OneOf + 1);\r
 \r
@@ -872,13 +924,15 @@ ParseHiiQuestionOneOf (
   Parse Hii Question CheckBox.\r
 \r
   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.\r
+  @param[in] StoredInBitField   Whether the CheckBox is stored in bit field Storage.\r
 \r
   return Pointer to Hii Question.\r
 \r
 **/\r
 VAR_CHECK_HII_QUESTION_HEADER *\r
 ParseHiiQuestionCheckBox (\r
-  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader\r
+  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader,\r
+  IN BOOLEAN            StoredInBitField\r
   )\r
 {\r
   EFI_IFR_CHECKBOX                  *IfrCheckBox;\r
@@ -888,10 +942,15 @@ ParseHiiQuestionCheckBox (
 \r
   CheckBox = InternalVarCheckAllocateZeroPool (sizeof (*CheckBox));\r
   ASSERT (CheckBox != NULL);\r
-  CheckBox->OpCode       = EFI_IFR_CHECKBOX_OP;\r
-  CheckBox->Length       = (UINT8) sizeof (*CheckBox);;\r
-  CheckBox->VarOffset    = IfrCheckBox->Question.VarStoreInfo.VarOffset;\r
-  CheckBox->StorageWidth = (UINT8) sizeof (BOOLEAN);\r
+  CheckBox->OpCode         = EFI_IFR_CHECKBOX_OP;\r
+  CheckBox->Length         = (UINT8) sizeof (*CheckBox);;\r
+  CheckBox->VarOffset      = IfrCheckBox->Question.VarStoreInfo.VarOffset;\r
+  CheckBox->BitFieldStore  = StoredInBitField;\r
+  if (StoredInBitField) {\r
+    CheckBox->StorageWidth = 1;\r
+  } else {\r
+    CheckBox->StorageWidth = (UINT8) sizeof (BOOLEAN);\r
+  }\r
 \r
   return (VAR_CHECK_HII_QUESTION_HEADER *) CheckBox;\r
 }\r
@@ -900,30 +959,48 @@ ParseHiiQuestionCheckBox (
   Parse Hii Question Numeric.\r
 \r
   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.\r
+  @param[in] StoredInBitField   Whether the Numeric is stored in bit field Storage.\r
 \r
   return Pointer to Hii Question.\r
 \r
 **/\r
 VAR_CHECK_HII_QUESTION_HEADER *\r
 ParseHiiQuestionNumeric (\r
-  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader\r
+  IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader,\r
+  IN BOOLEAN            StoredInBitField\r
   )\r
 {\r
   EFI_IFR_NUMERIC                   *IfrNumeric;\r
   VAR_CHECK_HII_QUESTION_NUMERIC    *Numeric;\r
   UINT8                             Width;\r
+  UINT8                             BitWidth;\r
 \r
   IfrNumeric = (EFI_IFR_NUMERIC *) IfrOpCodeHeader;\r
+  BitWidth = 0;\r
 \r
   Numeric = InternalVarCheckAllocateZeroPool (sizeof (VAR_CHECK_HII_QUESTION_NUMERIC) + 2 * sizeof (UINT64));\r
   ASSERT (Numeric != NULL);\r
 \r
-  Width = (UINT8) (1 << (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE));\r
+  if (StoredInBitField) {\r
+    //\r
+    // When Numeric stored in bit field, the bit field width is saved in the lower six bits of the flag.\r
+    // And the Minimum Maximum of Numeric is saved as UINT32 type.\r
+    //\r
+    BitWidth = IfrNumeric->Flags & EDKII_IFR_NUMERIC_SIZE_BIT;\r
+    Width = sizeof (UINT32);\r
+  } else {\r
+    Width = (UINT8) (1 << (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE));\r
+  }\r
 \r
-  Numeric->OpCode       = EFI_IFR_NUMERIC_OP;\r
-  Numeric->Length       = (UINT8) (sizeof (VAR_CHECK_HII_QUESTION_NUMERIC) + 2 * Width);\r
-  Numeric->VarOffset    = IfrNumeric->Question.VarStoreInfo.VarOffset;\r
-  Numeric->StorageWidth = Width;\r
+  Numeric->OpCode         = EFI_IFR_NUMERIC_OP;\r
+  Numeric->Length         = (UINT8) (sizeof (VAR_CHECK_HII_QUESTION_NUMERIC) + 2 * Width);\r
+  Numeric->VarOffset      = IfrNumeric->Question.VarStoreInfo.VarOffset;\r
+  Numeric->BitFieldStore  = StoredInBitField;\r
+  if (StoredInBitField) {\r
+    Numeric->StorageWidth = BitWidth;\r
+  } else {\r
+    Numeric->StorageWidth = Width;\r
+  }\r
 \r
   CopyMem (Numeric + 1, &IfrNumeric->data, Width * 2);\r
 \r
@@ -962,6 +1039,7 @@ ParseHiiQuestionOrderedList (
   OrderedList->VarOffset     = IfrOrderedList->Question.VarStoreInfo.VarOffset;\r
   OrderedList->StorageWidth  = OptionWidth;\r
   OrderedList->MaxContainers = IfrOrderedList->MaxContainers;\r
+  OrderedList->BitFieldStore = FALSE;\r
 \r
   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, OrderedList + 1);\r
 \r
@@ -974,28 +1052,34 @@ ParseHiiQuestionOrderedList (
   @param[in] HiiVariableNode    Pointer to Hii Variable node.\r
   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.\r
   @param[in] FromFv             Hii Question from FV.\r
+  @param[in] StoredInBitField   Whether the Question is stored in bit field Storage.\r
 \r
 **/\r
 VOID\r
 ParseHiiQuestion (\r
   IN VAR_CHECK_HII_VARIABLE_NODE    *HiiVariableNode,\r
   IN  EFI_IFR_OP_HEADER             *IfrOpCodeHeader,\r
-  IN BOOLEAN                        FromFv\r
+  IN BOOLEAN                        FromFv,\r
+  IN BOOLEAN                        StoredInBitField\r
   )\r
 {\r
   VAR_CHECK_HII_QUESTION_HEADER *HiiQuestion;\r
+  UINT16                        ArrayIndex;\r
 \r
+  //\r
+  // Currently only OneOf, CheckBox and Numeric can be stored in bit field.\r
+  //\r
   switch (IfrOpCodeHeader->OpCode) {\r
     case EFI_IFR_ONE_OF_OP:\r
-      HiiQuestion = ParseHiiQuestionOneOf (IfrOpCodeHeader);\r
+      HiiQuestion = ParseHiiQuestionOneOf (IfrOpCodeHeader, StoredInBitField);\r
       break;\r
 \r
     case EFI_IFR_CHECKBOX_OP:\r
-      HiiQuestion = ParseHiiQuestionCheckBox (IfrOpCodeHeader);\r
+      HiiQuestion = ParseHiiQuestionCheckBox (IfrOpCodeHeader, StoredInBitField);\r
       break;\r
 \r
     case EFI_IFR_NUMERIC_OP:\r
-      HiiQuestion = ParseHiiQuestionNumeric (IfrOpCodeHeader);\r
+      HiiQuestion = ParseHiiQuestionNumeric (IfrOpCodeHeader, StoredInBitField);\r
       break;\r
 \r
     case EFI_IFR_ORDERED_LIST_OP:\r
@@ -1008,10 +1092,15 @@ ParseHiiQuestion (
       break;\r
   }\r
 \r
-  if (HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset] != NULL) {\r
+  if (StoredInBitField) {\r
+    ArrayIndex = HiiQuestion->VarOffset;\r
+  } else {\r
+    ArrayIndex = HiiQuestion->VarOffset * 8;\r
+  }\r
+  if (HiiVariableNode->HiiQuestionArray[ArrayIndex] != NULL) {\r
     MergeHiiQuestion (HiiVariableNode, HiiQuestion, FromFv);\r
   } else {\r
-    HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset] = HiiQuestion;\r
+    HiiVariableNode->HiiQuestionArray[ArrayIndex] = HiiQuestion;\r
   }\r
 }\r
 \r
@@ -1166,7 +1255,7 @@ CreateHiiVariableNode (
     // The variable store identifier, which is unique within the current form set.\r
     //\r
     HiiVariableNode->VarStoreId = IfrEfiVarStore->VarStoreId;\r
-    HiiVariableNode->HiiQuestionArray = InternalVarCheckAllocateZeroPool (IfrEfiVarStore->Size * sizeof (VAR_CHECK_HII_QUESTION_HEADER *));\r
+    HiiVariableNode->HiiQuestionArray = InternalVarCheckAllocateZeroPool (IfrEfiVarStore->Size * 8 * sizeof (VAR_CHECK_HII_QUESTION_HEADER *));\r
 \r
     InsertTailList (&mVarCheckHiiList, &HiiVariableNode->Link);\r
   } else {\r
@@ -1239,6 +1328,7 @@ VarCheckParseHiiPackage (
   EFI_HII_PACKAGE_HEADER        *HiiPackageHeader;\r
   EFI_IFR_OP_HEADER             *IfrOpCodeHeader;\r
   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;\r
+  BOOLEAN                       QuestionStoredInBitField;\r
 \r
   //\r
   // Parse and create Hii Variable node list for this Hii Package.\r
@@ -1247,12 +1337,24 @@ VarCheckParseHiiPackage (
 \r
   HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiPackage;\r
 \r
+  QuestionStoredInBitField = FALSE;\r
+\r
   switch (HiiPackageHeader->Type) {\r
     case EFI_HII_PACKAGE_FORMS:\r
       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) (HiiPackageHeader + 1);\r
 \r
       while ((UINTN) IfrOpCodeHeader < (UINTN) HiiPackageHeader + HiiPackageHeader->Length) {\r
         switch (IfrOpCodeHeader->OpCode) {\r
+          case EFI_IFR_GUID_OP:\r
+            if (CompareGuid ((EFI_GUID *)((UINTN)IfrOpCodeHeader + sizeof (EFI_IFR_OP_HEADER)), &gEdkiiIfrBitVarstoreGuid)) {\r
+              QuestionStoredInBitField = TRUE;\r
+            }\r
+            break;\r
+\r
+          case EFI_IFR_END_OP:\r
+            QuestionStoredInBitField = FALSE;\r
+            break;\r
+\r
           case EFI_IFR_ONE_OF_OP:\r
           case EFI_IFR_CHECKBOX_OP:\r
           case EFI_IFR_NUMERIC_OP:\r
@@ -1270,7 +1372,7 @@ VarCheckParseHiiPackage (
               //\r
               // Normal IFR\r
               //\r
-              ParseHiiQuestion (HiiVariableNode, IfrOpCodeHeader, FromFv);\r
+              ParseHiiQuestion (HiiVariableNode, IfrOpCodeHeader, FromFv, QuestionStoredInBitField);\r
             }\r
           default:\r
             break;\r
@@ -1341,7 +1443,7 @@ DestroyHiiVariableNode (
     //\r
     // Free the allocated buffer.\r
     //\r
-    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {\r
+    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size * (UINTN) 8; Index++) {\r
       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {\r
         InternalVarCheckFreePool (HiiVariableNode->HiiQuestionArray[Index]);\r
       }\r
@@ -1389,7 +1491,7 @@ BuildVarCheckHiiBin (
     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (HiiVariableLink);\r
     HiiVariableLength = HiiVariableNode->HiiVariable->HeaderLength;\r
 \r
-    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {\r
+    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size * (UINTN) 8; Index++) {\r
       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {\r
         //\r
         // For Hii Question header align.\r
@@ -1434,7 +1536,7 @@ BuildVarCheckHiiBin (
     CopyMem (Ptr, HiiVariableNode->HiiVariable, HiiVariableNode->HiiVariable->HeaderLength);\r
     Ptr += HiiVariableNode->HiiVariable->HeaderLength;\r
 \r
-    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {\r
+    for (Index = 0; Index < HiiVariableNode->HiiVariable->Size * (UINTN) 8; Index++) {\r
       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {\r
         //\r
         // For Hii Question header align.\r

diff --git a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLib.inf b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLib.inf
index 98e6983f6c2bb1464ba5e1fd934b294b8a47eef2..aeca3ef7d5e50973b461a770e8e1adf6a70b188b 100644 (file)
--- a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLib.inf
+++ b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLib.inf
@@ -1,7 +1,7 @@
 ## @file\r
 #  NULL class library to register var check HII handler.\r
 #\r
-#  Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
+#  Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
 #\r
 #  This program and the accompanying materials\r
 #  are licensed and made available under the terms and conditions\r
@@ -46,6 +46,9 @@
   PcdLib\r
   VarCheckLib\r
 \r
+[Guids]\r
+  gEdkiiIfrBitVarstoreGuid                  ## SOMETIMES_CONSUMES  ## GUID\r
+\r
 [Protocols]\r
   gEfiFirmwareVolume2ProtocolGuid           ## SOMETIMES_CONSUMES\r
   gEfiFirmwareVolumeBlock2ProtocolGuid      ## SOMETIMES_CONSUMES\r

diff --git a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLibNullClass.c b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLibNullClass.c
index 46a93bdb8a1b65e6112b5f25e4294a33cda74028..93ac5ec8f1cc6e33ecdc7dae557ff58a93c27b19 100644 (file)
--- a/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLibNullClass.c
+++ b/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLibNullClass.c
@@ -93,28 +93,61 @@ VarCheckHiiQuestion (
   UINT8    *Ptr;\r
   UINT8    Index;\r
   UINT8    MaxContainers;\r
+  UINT8    StartBit;\r
+  UINT8    EndBit;\r
+  UINT8    TotalBits;\r
+  UINT16   VarOffsetByteLevel;\r
+  UINT8    StorageWidthByteLevel;\r
+\r
+  if (HiiQuestion->BitFieldStore) {\r
+    VarOffsetByteLevel    = HiiQuestion->VarOffset / 8;\r
+    TotalBits             = HiiQuestion->VarOffset % 8 + HiiQuestion->StorageWidth;\r
+    StorageWidthByteLevel = (TotalBits % 8 == 0 ? TotalBits / 8: TotalBits / 8 + 1);\r
+  } else {\r
+    VarOffsetByteLevel    = HiiQuestion->VarOffset;\r
+    StorageWidthByteLevel = HiiQuestion->StorageWidth;\r
+  }\r
 \r
-  if (((UINT32) HiiQuestion->VarOffset + HiiQuestion->StorageWidth) > DataSize) {\r
-    DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: (VarOffset(0x%04x) + StorageWidth(0x%02x)) > Size(0x%x)\n", HiiQuestion->VarOffset, HiiQuestion->StorageWidth, DataSize));\r
+  if (((UINT32) VarOffsetByteLevel + StorageWidthByteLevel) > DataSize) {\r
+    DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: (VarOffset(0x%04x) + StorageWidth(0x%02x)) > Size(0x%x)\n", VarOffsetByteLevel, StorageWidthByteLevel, DataSize));\r
     return FALSE;\r
   }\r
 \r
   OneData = 0;\r
-  CopyMem (&OneData, (UINT8 *) Data + HiiQuestion->VarOffset, HiiQuestion->StorageWidth);\r
+  CopyMem (&OneData, (UINT8 *) Data + VarOffsetByteLevel, StorageWidthByteLevel);\r
+  if (HiiQuestion->BitFieldStore) {\r
+    //\r
+    // Get the value from the bit field.\r
+    //\r
+    StartBit = HiiQuestion->VarOffset % 8;\r
+    EndBit   = StartBit + HiiQuestion->StorageWidth - 1;\r
+    OneData  = BitFieldRead64 (OneData, StartBit, EndBit);\r
+  }\r
 \r
   switch (HiiQuestion->OpCode) {\r
     case EFI_IFR_ONE_OF_OP:\r
       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion + 1);\r
       while ((UINTN) Ptr < (UINTN) HiiQuestion + HiiQuestion->Length) {\r
         OneValue = 0;\r
-        CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);\r
+        if (HiiQuestion->BitFieldStore) {\r
+          //\r
+          // For OneOf stored in bit field, the value of options are saved as UINT32 type.\r
+          //\r
+          CopyMem (&OneValue, Ptr, sizeof (UINT32));\r
+        } else {\r
+          CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);\r
+        }\r
         if (OneData == OneValue) {\r
           //\r
           // Match\r
           //\r
           break;\r
         }\r
-        Ptr += HiiQuestion->StorageWidth;\r
+        if (HiiQuestion->BitFieldStore) {\r
+          Ptr += sizeof (UINT32);\r
+        } else {\r
+          Ptr += HiiQuestion->StorageWidth;\r
+        }\r
       }\r
       if ((UINTN) Ptr >= ((UINTN) HiiQuestion + HiiQuestion->Length)) {\r
         //\r
@@ -138,10 +171,20 @@ VarCheckHiiQuestion (
       Minimum = 0;\r
       Maximum = 0;\r
       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion + 1);\r
-      CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);\r
-      Ptr += HiiQuestion->StorageWidth;\r
-      CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);\r
-      Ptr += HiiQuestion->StorageWidth;\r
+      if (HiiQuestion->BitFieldStore) {\r
+        //\r
+        // For Numeric stored in bit field, the value of Maximum/Minimum are saved as UINT32 type.\r
+        //\r
+        CopyMem (&Minimum, Ptr, sizeof (UINT32));\r
+        Ptr += sizeof (UINT32);\r
+        CopyMem (&Maximum, Ptr, sizeof (UINT32));\r
+        Ptr += sizeof (UINT32);\r
+      } else {\r
+        CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);\r
+        Ptr += HiiQuestion->StorageWidth;\r
+        CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);\r
+        Ptr += HiiQuestion->StorageWidth;\r
+      }\r
 \r
       //\r
       // No need to check Step, because it is ONLY for UI.\r
@@ -344,70 +387,95 @@ DumpHiiQuestion (
   UINT8     *Ptr;\r
 \r
   DEBUG ((DEBUG_INFO, "  VAR_CHECK_HII_QUESTION_HEADER\n"));\r
-  DEBUG ((DEBUG_INFO, "    OpCode        - 0x%02x (%a)\n", HiiQuestion->OpCode, HiiOpCodeToStr (HiiQuestion->OpCode)));\r
+  DEBUG ((DEBUG_INFO, "    OpCode        - 0x%02x (%a) (%a)\n", HiiQuestion->OpCode, HiiOpCodeToStr (HiiQuestion->OpCode), (HiiQuestion->BitFieldStore? "bit level": "byte level")));\r
   DEBUG ((DEBUG_INFO, "    Length        - 0x%02x\n", HiiQuestion->Length));\r
-  DEBUG ((DEBUG_INFO, "    VarOffset     - 0x%04x\n", HiiQuestion->VarOffset));\r
-  DEBUG ((DEBUG_INFO, "    StorageWidth  - 0x%02x\n", HiiQuestion->StorageWidth));\r
+  DEBUG ((DEBUG_INFO, "    VarOffset     - 0x%04x (%a)\n", HiiQuestion->VarOffset, (HiiQuestion->BitFieldStore? "bit level": "byte level")));\r
+  DEBUG ((DEBUG_INFO, "    StorageWidth  - 0x%02x (%a)\n", HiiQuestion->StorageWidth, (HiiQuestion->BitFieldStore? "bit level": "byte level")));\r
 \r
   switch (HiiQuestion->OpCode) {\r
     case EFI_IFR_ONE_OF_OP:\r
       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion + 1);\r
       while ((UINTN) Ptr < ((UINTN) HiiQuestion + HiiQuestion->Length)) {\r
         OneValue = 0;\r
-        CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);\r
+        if (HiiQuestion->BitFieldStore) {\r
+          //\r
+          // For OneOf stored in bit field, the value of options are saved as UINT32 type.\r
+          //\r
+          CopyMem (&OneValue, Ptr, sizeof (UINT32));\r
+          DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));\r
+        } else {\r
+          CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);\r
+          switch (HiiQuestion->StorageWidth) {\r
+            case sizeof (UINT8):\r
+              DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%02x\n", OneValue));\r
+              break;\r
+            case sizeof (UINT16):\r
+              DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%04x\n", OneValue));\r
+              break;\r
+            case sizeof (UINT32):\r
+              DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));\r
+              break;\r
+            case sizeof (UINT64):\r
+              DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%016lx\n", OneValue));\r
+              break;\r
+            default:\r
+              ASSERT (FALSE);\r
+              break;\r
+          }\r
+        }\r
+        if (HiiQuestion->BitFieldStore) {\r
+          Ptr += sizeof (UINT32);\r
+        } else {\r
+          Ptr += HiiQuestion->StorageWidth;\r
+        }\r
+      }\r
+      break;\r
+\r
+    case EFI_IFR_CHECKBOX_OP:\r
+      break;\r
+\r
+    case EFI_IFR_NUMERIC_OP:\r
+      Minimum = 0;\r
+      Maximum = 0;\r
+      Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion + 1);\r
+      if(HiiQuestion->BitFieldStore) {\r
+        //\r
+        // For Numeric stored in bit field, the value of Maximum/Minimum are saved as UINT32 type.\r
+        //\r
+        CopyMem (&Minimum, Ptr, sizeof (UINT32));\r
+        Ptr += sizeof (UINT32);\r
+        CopyMem (&Maximum, Ptr, sizeof (UINT32));\r
+        Ptr += sizeof (UINT32);\r
+\r
+        DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));\r
+        DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));\r
+      } else {\r
+        CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);\r
+        Ptr += HiiQuestion->StorageWidth;\r
+        CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);\r
+        Ptr += HiiQuestion->StorageWidth;\r
+\r
         switch (HiiQuestion->StorageWidth) {\r
           case sizeof (UINT8):\r
-            DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%02x\n", OneValue));\r
+            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%02x\n", Minimum));\r
+            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%02x\n", Maximum));\r
             break;\r
           case sizeof (UINT16):\r
-            DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%04x\n", OneValue));\r
+            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%04x\n", Minimum));\r
+            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%04x\n", Maximum));\r
             break;\r
           case sizeof (UINT32):\r
-            DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));\r
+            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));\r
+            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));\r
             break;\r
           case sizeof (UINT64):\r
-            DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%016lx\n", OneValue));\r
+            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%016lx\n", Minimum));\r
+            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%016lx\n", Maximum));\r
             break;\r
           default:\r
             ASSERT (FALSE);\r
             break;\r
         }\r
-        Ptr += HiiQuestion->StorageWidth;\r
-      }\r
-      break;\r
-\r
-    case EFI_IFR_CHECKBOX_OP:\r
-      break;\r
-\r
-    case EFI_IFR_NUMERIC_OP:\r
-      Minimum = 0;\r
-      Maximum = 0;\r
-      Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion + 1);\r
-      CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);\r
-      Ptr += HiiQuestion->StorageWidth;\r
-      CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);\r
-      Ptr += HiiQuestion->StorageWidth;\r
-\r
-      switch (HiiQuestion->StorageWidth) {\r
-        case sizeof (UINT8):\r
-          DEBUG ((DEBUG_INFO, "    Minimum       - 0x%02x\n", Minimum));\r
-          DEBUG ((DEBUG_INFO, "    Maximum       - 0x%02x\n", Maximum));\r
-          break;\r
-        case sizeof (UINT16):\r
-          DEBUG ((DEBUG_INFO, "    Minimum       - 0x%04x\n", Minimum));\r
-          DEBUG ((DEBUG_INFO, "    Maximum       - 0x%04x\n", Maximum));\r
-          break;\r
-        case sizeof (UINT32):\r
-          DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));\r
-          DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));\r
-          break;\r
-        case sizeof (UINT64):\r
-          DEBUG ((DEBUG_INFO, "    Minimum       - 0x%016lx\n", Minimum));\r
-          DEBUG ((DEBUG_INFO, "    Maximum       - 0x%016lx\n", Maximum));\r
-          break;\r
-        default:\r
-          ASSERT (FALSE);\r
-          break;\r
       }\r
       break;\r
 \r