BaseTools/Source/C/VfrCompile/VfrUtilityLib.h

   1 /** @file
   2
   3   Vfr common library functions.
   4
   5 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
   6 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 #ifndef _VFRUTILITYLIB_H_
  17 #define _VFRUTILITYLIB_H_
  18
  19 #include "string.h"
  20 #include "Common/UefiBaseTypes.h"
  21 #include "EfiVfr.h"
  22 #include "VfrError.h"
  23
  24 extern BOOLEAN  VfrCompatibleMode;
  25
  26 #define MAX_NAME_LEN                       64
  27 #define MAX_STRING_LEN                     0x100
  28 #define DEFAULT_ALIGN                      1
  29 #define DEFAULT_PACK_ALIGN                 0x8
  30 #define DEFAULT_NAME_TABLE_ITEMS           1024
  31
  32 #define EFI_BITS_SHIFT_PER_UINT32          0x5
  33 #define EFI_BITS_PER_UINT32                (1 << EFI_BITS_SHIFT_PER_UINT32)
  34
  35 #define BUFFER_SAFE_FREE(Buf)              do { if ((Buf) != NULL) { delete (Buf); } } while (0);
  36 #define ARRAY_SAFE_FREE(Buf)               do { if ((Buf) != NULL) { delete[] (Buf); } } while (0);
  37
  38
  39 class CVfrBinaryOutput {
  40 public:
  41   virtual VOID WriteLine (IN FILE *, IN UINT32, IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);
  42   virtual VOID WriteEnd (IN FILE *, IN UINT32, IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);
  43 };
  44
  45 UINT32
  46 _STR2U32 (
  47   IN CHAR8 *Str
  48   );
  49
  50 struct SConfigInfo {
  51   UINT16             mOffset;
  52   UINT16             mWidth;
  53   UINT8              *mValue;
  54   SConfigInfo        *mNext;
  55
  56   SConfigInfo (IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
  57   ~SConfigInfo (VOID);
  58 };
  59
  60 struct SConfigItem {
  61   CHAR8         *mName;         // varstore name
  62   EFI_GUID      *mGuid;         // varstore guid, varstore name + guid deside one varstore
  63   CHAR8         *mId;           // default ID
  64   SConfigInfo   *mInfoStrList;  // list of Offset/Value in the varstore
  65   SConfigItem   *mNext;
  66
  67 public:
  68   SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *);
  69   SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT16, IN EFI_IFR_TYPE_VALUE);
  70   virtual ~SConfigItem ();
  71 };
  72
  73 class CVfrBufferConfig {
  74 private:
  75   SConfigItem *mItemListHead;
  76   SConfigItem *mItemListTail;
  77   SConfigItem *mItemListPos;
  78
  79 public:
  80   CVfrBufferConfig (VOID);
  81   virtual ~CVfrBufferConfig (VOID);
  82
  83   virtual UINT8   Register (IN CHAR8 *, IN EFI_GUID *,IN CHAR8 *Info = NULL);
  84   virtual VOID    Open (VOID);
  85   virtual BOOLEAN Eof(VOID);
  86   virtual UINT8   Select (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *Info = NULL);
  87   virtual UINT8   Write (IN CONST CHAR8, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
  88 #if 0
  89   virtual UINT8   Read (OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **);
  90 #endif
  91   virtual VOID    Close (VOID);
  92   virtual VOID    OutputCFile (IN FILE *, IN CHAR8 *);
  93 };
  94
  95 extern CVfrBufferConfig gCVfrBufferConfig;
  96
  97 #define ALIGN_STUFF(Size, Align) ((Align) - (Size) % (Align))
  98 #define INVALID_ARRAY_INDEX      0xFFFFFFFF
  99
 100 struct SVfrDataType;
 101
 102 struct SVfrDataField {
 103   CHAR8                     mFieldName[MAX_NAME_LEN];
 104   SVfrDataType              *mFieldType;
 105   UINT32                    mOffset;
 106   UINT32                    mArrayNum;
 107   SVfrDataField             *mNext;
 108 };
 109
 110 struct SVfrDataType {
 111   CHAR8                     mTypeName[MAX_NAME_LEN];
 112   UINT8                     mType;
 113   UINT32                    mAlign;
 114   UINT32                    mTotalSize;
 115   SVfrDataField             *mMembers;
 116   SVfrDataType              *mNext;
 117 };
 118
 119 #define VFR_PACK_ASSIGN     0x01
 120 #define VFR_PACK_SHOW       0x02
 121 #define VFR_PACK_PUSH       0x04
 122 #define VFR_PACK_POP        0x08
 123
 124 #define PACKSTACK_MAX_SIZE  0x400
 125
 126 struct SVfrPackStackNode {
 127   CHAR8                     *mIdentifier;
 128   UINT32                    mNumber;
 129   SVfrPackStackNode         *mNext;
 130
 131   SVfrPackStackNode (IN CHAR8 *Identifier, IN UINT32 Number) {
 132     mIdentifier = NULL;
 133     mNumber     = Number;
 134     mNext       = NULL;
 135
 136     if (Identifier != NULL) {
 137       mIdentifier = new CHAR8[strlen (Identifier) + 1];
 138       strcpy (mIdentifier, Identifier);
 139     }
 140   }
 141
 142   ~SVfrPackStackNode (VOID) {
 143     if (mIdentifier != NULL) {
 144       delete[] mIdentifier;
 145     }
 146     mNext = NULL;
 147   }
 148
 149   bool Match (IN CHAR8 *Identifier) {
 150     if (Identifier == NULL) {
 151       return TRUE;
 152     } else if (mIdentifier == NULL) {
 153       return FALSE;
 154     } else if (strcmp (Identifier, mIdentifier) == 0) {
 155       return TRUE;
 156     } else {
 157       return FALSE;
 158     }
 159   }
 160 };
 161
 162 class CVfrVarDataTypeDB {
 163 private:
 164   UINT32                    mPackAlign;
 165   SVfrPackStackNode         *mPackStack;
 166
 167 public:
 168   EFI_VFR_RETURN_CODE       Pack (IN UINT32, IN UINT8, IN CHAR8 *Identifier = NULL, IN UINT32 Number = DEFAULT_PACK_ALIGN);
 169
 170 private:
 171   SVfrDataType              *mDataTypeList;
 172
 173   SVfrDataType              *mNewDataType;
 174   SVfrDataType              *mCurrDataType;
 175   SVfrDataField             *mCurrDataField;
 176
 177   VOID InternalTypesListInit (VOID);
 178   VOID RegisterNewType (IN SVfrDataType *);
 179
 180   EFI_VFR_RETURN_CODE ExtractStructTypeName (IN CHAR8 *&, OUT CHAR8 *);
 181   EFI_VFR_RETURN_CODE GetTypeField (IN CONST CHAR8 *, IN SVfrDataType *, IN SVfrDataField *&);
 182   EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT UINT32 &);
 183   UINT8               GetFieldWidth (IN SVfrDataField *);
 184   UINT32              GetFieldSize (IN SVfrDataField *, IN UINT32);
 185
 186 public:
 187   CVfrVarDataTypeDB (VOID);
 188   ~CVfrVarDataTypeDB (VOID);
 189
 190   VOID                DeclareDataTypeBegin (VOID);
 191   EFI_VFR_RETURN_CODE SetNewTypeName (IN CHAR8 *);
 192   EFI_VFR_RETURN_CODE DataTypeAddField (IN CHAR8 *, IN CHAR8 *, IN UINT32);
 193   VOID                DeclareDataTypeEnd (VOID);
 194
 195   EFI_VFR_RETURN_CODE GetDataType (IN CHAR8 *, OUT SVfrDataType **);
 196   EFI_VFR_RETURN_CODE GetDataTypeSize (IN CHAR8 *, OUT UINT32 *);
 197   EFI_VFR_RETURN_CODE GetDataTypeSize (IN UINT8, OUT UINT32 *);
 198   EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, OUT UINT32 &);
 199
 200   EFI_VFR_RETURN_CODE GetUserDefinedTypeNameList (OUT CHAR8 ***, OUT UINT32 *);
 201   EFI_VFR_RETURN_CODE ExtractFieldNameAndArrary (IN CHAR8 *&, OUT CHAR8 *, OUT UINT32 &);
 202
 203   BOOLEAN             IsTypeNameDefined (IN CHAR8 *);
 204
 205   VOID                Dump(IN FILE *);
 206   //
 207   // First the declared
 208   //
 209   CHAR8               *mFirstNewDataTypeName;
 210 #ifdef CVFR_VARDATATYPEDB_DEBUG
 211   VOID ParserDB ();
 212 #endif
 213 };
 214
 215 extern CVfrVarDataTypeDB  gCVfrVarDataTypeDB;
 216
 217 typedef enum {
 218   EFI_VFR_VARSTORE_INVALID,
 219   EFI_VFR_VARSTORE_BUFFER,
 220   EFI_VFR_VARSTORE_EFI,
 221   EFI_VFR_VARSTORE_NAME
 222 } EFI_VFR_VARSTORE_TYPE;
 223
 224 struct SVfrVarStorageNode {
 225   EFI_GUID                  mGuid;
 226   CHAR8                     *mVarStoreName;
 227   EFI_VARSTORE_ID           mVarStoreId;
 228   BOOLEAN                   mAssignedFlag; //Create varstore opcode
 229   struct SVfrVarStorageNode *mNext;
 230
 231   EFI_VFR_VARSTORE_TYPE     mVarStoreType;
 232   union {
 233     // EFI Variable
 234     struct {
 235       EFI_STRING_ID           mEfiVarName;
 236       UINT32                  mEfiVarSize;
 237     } mEfiVar;
 238
 239     // Buffer Storage
 240     SVfrDataType            *mDataType;
 241
 242     // NameValue Storage
 243         struct {
 244       EFI_STRING_ID         *mNameTable;
 245       UINT32                mTableSize;
 246     } mNameSpace;
 247   } mStorageInfo;
 248
 249 public:
 250   SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
 251   SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN SVfrDataType *, IN BOOLEAN Flag = TRUE);
 252   SVfrVarStorageNode (IN CHAR8 *, IN EFI_VARSTORE_ID);
 253   ~SVfrVarStorageNode (VOID);
 254 };
 255
 256 struct EFI_VARSTORE_INFO {
 257   EFI_VARSTORE_ID           mVarStoreId;
 258   union {
 259     EFI_STRING_ID           mVarName;
 260     UINT16                  mVarOffset;
 261   } mInfo;
 262   UINT8                     mVarType;
 263   UINT32                    mVarTotalSize;
 264
 265   EFI_VARSTORE_INFO (VOID);
 266   EFI_VARSTORE_INFO (IN EFI_VARSTORE_INFO &);
 267   EFI_VARSTORE_INFO& operator=(IN CONST EFI_VARSTORE_INFO &);
 268   BOOLEAN operator == (IN EFI_VARSTORE_INFO *);
 269 };
 270
 271 struct BufferVarStoreFieldInfoNode {
 272   EFI_VARSTORE_INFO  mVarStoreInfo;
 273   struct BufferVarStoreFieldInfoNode *mNext;
 274
 275   BufferVarStoreFieldInfoNode( IN EFI_VARSTORE_INFO  *Info );
 276   ~BufferVarStoreFieldInfoNode ();
 277 };
 278
 279 #define EFI_VARSTORE_ID_MAX              0xFFFF
 280 #define EFI_FREE_VARSTORE_ID_BITMAP_SIZE ((EFI_VARSTORE_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 281
 282 class CVfrDataStorage {
 283 private:
 284   UINT32                    mFreeVarStoreIdBitMap[EFI_FREE_VARSTORE_ID_BITMAP_SIZE];
 285
 286   struct SVfrVarStorageNode *mBufferVarStoreList;
 287   struct SVfrVarStorageNode *mEfiVarStoreList;
 288   struct SVfrVarStorageNode *mNameVarStoreList;
 289
 290   struct SVfrVarStorageNode *mCurrVarStorageNode;
 291   struct SVfrVarStorageNode *mNewVarStorageNode;
 292   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListHead;
 293   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListTail;
 294
 295 private:
 296
 297   EFI_VARSTORE_ID GetFreeVarStoreId (EFI_VFR_VARSTORE_TYPE VarType = EFI_VFR_VARSTORE_BUFFER);
 298   BOOLEAN         ChekVarStoreIdFree (IN EFI_VARSTORE_ID);
 299   VOID            MarkVarStoreIdUsed (IN EFI_VARSTORE_ID);
 300   VOID            MarkVarStoreIdUnused (IN EFI_VARSTORE_ID);
 301   EFI_VARSTORE_ID CheckGuidField (IN SVfrVarStorageNode *,
 302                                   IN EFI_GUID *,
 303                                   IN BOOLEAN *,
 304                                   OUT EFI_VFR_RETURN_CODE *);
 305
 306 public:
 307   CVfrDataStorage ();
 308   ~CVfrDataStorage ();
 309
 310   SVfrVarStorageNode * GetBufferVarStoreList () {
 311     return mBufferVarStoreList;
 312   }
 313   SVfrVarStorageNode * GetEfiVarStoreList () {
 314     return mEfiVarStoreList;
 315   }
 316   EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *, EFI_VARSTORE_ID);
 317   EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);
 318   EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);
 319
 320   EFI_VFR_RETURN_CODE DeclareEfiVarStore (IN CHAR8 *, IN EFI_GUID *, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
 321
 322   EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE);
 323
 324   EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *, IN EFI_GUID *VarGuid = NULL);
 325   EFI_VFR_VARSTORE_TYPE GetVarStoreType (IN EFI_VARSTORE_ID);
 326   EFI_GUID *          GetVarStoreGuid (IN  EFI_VARSTORE_ID);
 327   EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT CHAR8 **);
 328   EFI_VFR_RETURN_CODE GetVarStoreByDataType (IN CHAR8 *, OUT SVfrVarStorageNode **, IN EFI_GUID *VarGuid = NULL);
 329
 330   EFI_VFR_RETURN_CODE GetBufferVarStoreDataTypeName (IN EFI_VARSTORE_ID, OUT CHAR8 **);
 331   EFI_VFR_RETURN_CODE GetEfiVarStoreInfo (IN EFI_VARSTORE_INFO *);
 332   EFI_VFR_RETURN_CODE GetNameVarStoreInfo (IN EFI_VARSTORE_INFO *, IN UINT32);
 333   EFI_VFR_RETURN_CODE AddBufferVarStoreFieldInfo (IN EFI_VARSTORE_INFO *);
 334   EFI_VFR_RETURN_CODE GetBufferVarStoreFieldInfo (IN OUT EFI_VARSTORE_INFO *);
 335 };
 336
 337 extern CVfrDataStorage gCVfrDataStorage;
 338
 339 #define EFI_QUESTION_ID_MAX              0xFFFF
 340 #define EFI_FREE_QUESTION_ID_BITMAP_SIZE ((EFI_QUESTION_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 341 #define EFI_QUESTION_ID_INVALID          0x0
 342
 343 #define DATE_YEAR_BITMASK                0x0000FFFF
 344 #define DATE_MONTH_BITMASK               0x00FF0000
 345 #define DATE_DAY_BITMASK                 0xFF000000
 346 #define TIME_HOUR_BITMASK                0x000000FF
 347 #define TIME_MINUTE_BITMASK              0x0000FF00
 348 #define TIME_SECOND_BITMASK              0x00FF0000
 349
 350 struct SVfrQuestionNode {
 351   CHAR8                     *mName;
 352   CHAR8                     *mVarIdStr;
 353   EFI_QUESTION_ID           mQuestionId;
 354   UINT32                    mBitMask;
 355   SVfrQuestionNode          *mNext;
 356   EFI_QUESION_TYPE          mQtype;
 357
 358   SVfrQuestionNode (IN CHAR8 *, IN CHAR8 *, IN UINT32 BitMask = 0);
 359   ~SVfrQuestionNode ();
 360 };
 361
 362 class CVfrQuestionDB {
 363 private:
 364   SVfrQuestionNode          *mQuestionList;
 365   UINT32                    mFreeQIdBitMap[EFI_FREE_QUESTION_ID_BITMAP_SIZE];
 366
 367 private:
 368   EFI_QUESTION_ID GetFreeQuestionId (VOID);
 369   BOOLEAN         ChekQuestionIdFree (IN EFI_QUESTION_ID);
 370   VOID            MarkQuestionIdUsed (IN EFI_QUESTION_ID);
 371   VOID            MarkQuestionIdUnused (IN EFI_QUESTION_ID);
 372
 373 public:
 374   CVfrQuestionDB ();
 375   ~CVfrQuestionDB();
 376
 377   EFI_VFR_RETURN_CODE RegisterQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 378   VOID                RegisterOldDateQuestion (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 379   VOID                RegisterNewDateQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 380   VOID                RegisterOldTimeQuestion (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 381   VOID                RegisterNewTimeQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 382   VOID                RegisterRefQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 383   EFI_VFR_RETURN_CODE UpdateQuestionId (IN EFI_QUESTION_ID, IN EFI_QUESTION_ID);
 384   VOID                GetQuestionId (IN CHAR8 *, IN CHAR8 *, OUT EFI_QUESTION_ID &, OUT UINT32 &, OUT EFI_QUESION_TYPE *QType = NULL);
 385   EFI_VFR_RETURN_CODE FindQuestion (IN EFI_QUESTION_ID);
 386   EFI_VFR_RETURN_CODE FindQuestion (IN CHAR8 *);
 387   VOID                PrintAllQuestion (IN VOID);
 388   VOID                ResetInit (IN VOID);
 389
 390   VOID SetCompatibleMode (IN BOOLEAN Mode) {
 391     VfrCompatibleMode = Mode;
 392   }
 393 };
 394
 395 struct SVfrDefaultStoreNode {
 396   EFI_IFR_DEFAULTSTORE      *mObjBinAddr;
 397   CHAR8                     *mRefName;
 398   EFI_STRING_ID             mDefaultStoreNameId;
 399   UINT16                    mDefaultId;
 400
 401   SVfrDefaultStoreNode      *mNext;
 402
 403   SVfrDefaultStoreNode (IN EFI_IFR_DEFAULTSTORE *, IN CHAR8 *, IN EFI_STRING_ID, IN UINT16);
 404   ~SVfrDefaultStoreNode();
 405 };
 406
 407 class CVfrDefaultStore {
 408 private:
 409   SVfrDefaultStoreNode      *mDefaultStoreList;
 410
 411 public:
 412   CVfrDefaultStore ();
 413   ~CVfrDefaultStore ();
 414
 415   EFI_VFR_RETURN_CODE RegisterDefaultStore (IN CHAR8 *, IN CHAR8 *, IN EFI_STRING_ID, IN UINT16);
 416   EFI_VFR_RETURN_CODE ReRegisterDefaultStoreById (IN UINT16, IN CHAR8 *, IN EFI_STRING_ID);
 417   BOOLEAN             DefaultIdRegistered (IN UINT16);
 418   EFI_VFR_RETURN_CODE GetDefaultId (IN CHAR8 *, OUT UINT16 *);
 419   EFI_VFR_RETURN_CODE BufferVarStoreAltConfigAdd (IN EFI_VARSTORE_ID, IN EFI_VARSTORE_INFO &, IN CHAR8 *, IN EFI_GUID *, IN UINT8, IN EFI_IFR_TYPE_VALUE);
 420 };
 421
 422 extern CVfrDefaultStore gCVfrDefaultStore;
 423
 424 #define EFI_RULE_ID_START    0x01
 425 #define EFI_RULE_ID_INVALID  0x00
 426
 427 struct SVfrRuleNode {
 428   UINT8                     mRuleId;
 429   CHAR8                     *mRuleName;
 430   SVfrRuleNode              *mNext;
 431
 432   SVfrRuleNode(IN CHAR8 *, IN UINT8);
 433   ~SVfrRuleNode();
 434 };
 435
 436 class CVfrRulesDB {
 437 private:
 438   SVfrRuleNode              *mRuleList;
 439   UINT8                     mFreeRuleId;
 440
 441 public:
 442   CVfrRulesDB ();
 443   ~CVfrRulesDB();
 444
 445   VOID RegisterRule (IN CHAR8 *);
 446   UINT8 GetRuleId (IN CHAR8 *);
 447 };
 448
 449 class CVfrStringDB {
 450 private:
 451   CHAR8   *mStringFileName;
 452
 453   EFI_STATUS FindStringBlock (
 454     IN  UINT8            *StringData,
 455     IN  EFI_STRING_ID    StringId,
 456     OUT UINT32           *StringTextOffset,
 457     OUT UINT8            *BlockType
 458     );
 459
 460   UINT32 GetUnicodeStringTextSize (
 461     IN  UINT8            *StringSrc
 462     );
 463
 464   BOOLEAN GetBestLanguage (
 465     IN CONST CHAR8  *SupportedLanguages,
 466     IN CHAR8        *Language
 467     );
 468
 469 public:
 470   CVfrStringDB ();
 471   ~CVfrStringDB ();
 472
 473   VOID SetStringFileName (
 474     IN CHAR8 *StringFileName
 475     );
 476
 477   CHAR8 * GetVarStoreNameFormStringId (
 478     IN EFI_STRING_ID StringId
 479     );
 480
 481 };
 482
 483 #endif