BaseTools/Source/C/VfrCompile/VfrUtilityLib.h

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