MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c

   1 /** @file
   2   This code produces the Smbios protocol. It also responsible for constructing
   3   SMBIOS table into system table.
   4
   5 Copyright (c) 2009 - 2015, 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 #include "SmbiosDxe.h"
  17
  18 //
  19 // Module Global:
  20 // Since this driver will only ever produce one instance of the
  21 // protocol you are not required to dynamically allocate the PrivateData.
  22 //
  23 SMBIOS_INSTANCE mPrivateData;
  24
  25 UINTN mPreAllocatedPages      = 0;
  26 UINTN mPre64BitAllocatedPages = 0;
  27
  28 //
  29 // Chassis for SMBIOS entry point structure that is to be installed into EFI system config table.
  30 //
  31 SMBIOS_TABLE_ENTRY_POINT *EntryPointStructure    = NULL;
  32 SMBIOS_TABLE_ENTRY_POINT EntryPointStructureData = {
  33   //
  34   // AnchorString
  35   //
  36   {
  37     0x5f,
  38     0x53,
  39     0x4d,
  40     0x5f
  41   },
  42   //
  43   // EntryPointStructureChecksum,TO BE FILLED
  44   //
  45   0,
  46   //
  47   // EntryPointStructure Length
  48   //
  49   0x1f,
  50   //
  51   // MajorVersion
  52   //
  53   0,
  54   //
  55   // MinorVersion
  56   //
  57   0,
  58   //
  59   // MaxStructureSize, TO BE FILLED
  60   //
  61   0,
  62   //
  63   // EntryPointRevision
  64   //
  65   0,
  66   //
  67   // FormattedArea
  68   //
  69   {
  70     0,
  71     0,
  72     0,
  73     0,
  74     0
  75   },
  76   //
  77   // IntermediateAnchorString
  78   //
  79   {
  80     0x5f,
  81     0x44,
  82     0x4d,
  83     0x49,
  84     0x5f
  85   },
  86   //
  87   // IntermediateChecksum, TO BE FILLED
  88   //
  89   0,
  90   //
  91   // TableLength, TO BE FILLED
  92   //
  93   0,
  94   //
  95   // TableAddress, TO BE FILLED
  96   //
  97   0,
  98   //
  99   // NumberOfSmbiosStructures, TO BE FILLED
 100   //
 101   0,
 102   //
 103   // SmbiosBcdRevision
 104   //
 105   0
 106 };
 107
 108 SMBIOS_TABLE_3_0_ENTRY_POINT *Smbios30EntryPointStructure    = NULL;
 109 SMBIOS_TABLE_3_0_ENTRY_POINT Smbios30EntryPointStructureData = {
 110   //
 111   // AnchorString _SM3_
 112   //
 113   {
 114     0x5f,
 115     0x53,
 116     0x4d,
 117     0x33,
 118     0x5f,
 119   },
 120   //
 121   // EntryPointStructureChecksum,TO BE FILLED
 122   //
 123   0,
 124   //
 125   // EntryPointLength
 126   //
 127   0x18,
 128   //
 129   // MajorVersion
 130   //
 131   0,
 132   //
 133   // MinorVersion
 134   //
 135   0,
 136   //
 137   // DocRev
 138   //
 139   0,
 140   //
 141   // EntryPointRevision
 142   //
 143   0x01,
 144   //
 145   // Reserved
 146   //
 147   0,
 148   //
 149   // TableMaximumSize,TO BE FILLED
 150   //
 151   0,
 152   //
 153   // TableAddress,TO BE FILLED
 154   //
 155   0
 156 };
 157 /**
 158
 159   Get the full size of SMBIOS structure including optional strings that follow the formatted structure.
 160
 161   @param This                   The EFI_SMBIOS_PROTOCOL instance.
 162   @param Head                   Pointer to the beginning of SMBIOS structure.
 163   @param Size                   The returned size.
 164   @param NumberOfStrings        The returned number of optional strings that follow the formatted structure.
 165
 166   @retval EFI_SUCCESS           Size retured in Size.
 167   @retval EFI_INVALID_PARAMETER Input SMBIOS structure mal-formed or Size is NULL.
 168
 169 **/
 170 EFI_STATUS
 171 EFIAPI
 172 GetSmbiosStructureSize (
 173   IN   CONST EFI_SMBIOS_PROTOCOL        *This,
 174   IN   EFI_SMBIOS_TABLE_HEADER          *Head,
 175   OUT  UINTN                            *Size,
 176   OUT  UINTN                            *NumberOfStrings
 177   )
 178 {
 179   UINTN  FullSize;
 180   UINTN  StrLen;
 181   UINTN  MaxLen;
 182   INT8*  CharInStr;
 183
 184   if (Size == NULL || NumberOfStrings == NULL) {
 185     return EFI_INVALID_PARAMETER;
 186   }
 187
 188   FullSize = Head->Length;
 189   CharInStr = (INT8*)Head + Head->Length;
 190   *Size = FullSize;
 191   *NumberOfStrings = 0;
 192   StrLen = 0;
 193   //
 194   // look for the two consecutive zeros, check the string limit by the way.
 195   //
 196   while (*CharInStr != 0 || *(CharInStr+1) != 0) {
 197     if (*CharInStr == 0) {
 198       *Size += 1;
 199       CharInStr++;
 200     }
 201
 202     if (This->MajorVersion < 2 || (This->MajorVersion == 2 && This->MinorVersion < 7)){
 203       MaxLen = SMBIOS_STRING_MAX_LENGTH;
 204     } else if (This->MajorVersion < 3) {
 205       //
 206       // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.
 207       // However, the length of the entire structure table (including all strings) must be reported
 208       // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
 209       // which is a WORD field limited to 65,535 bytes.
 210       //
 211       MaxLen = SMBIOS_TABLE_MAX_LENGTH;
 212     } else {
 213       //
 214       // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.
 215       // Locate the end of string as long as possible.
 216       //
 217       MaxLen = SMBIOS_3_0_TABLE_MAX_LENGTH;
 218     }
 219
 220     for (StrLen = 0 ; StrLen < MaxLen; StrLen++) {
 221       if (*(CharInStr+StrLen) == 0) {
 222         break;
 223       }
 224     }
 225
 226     if (StrLen == MaxLen) {
 227       return EFI_INVALID_PARAMETER;
 228     }
 229
 230     //
 231     // forward the pointer
 232     //
 233     CharInStr += StrLen;
 234     *Size += StrLen;
 235     *NumberOfStrings += 1;
 236   }
 237
 238   //
 239   // count ending two zeros.
 240   //
 241   *Size += 2;
 242   return EFI_SUCCESS;
 243 }
 244
 245 /**
 246
 247   Determin whether an SmbiosHandle has already in use.
 248
 249   @param Head        Pointer to the beginning of SMBIOS structure.
 250   @param Handle      A unique handle will be assigned to the SMBIOS record.
 251
 252   @retval TRUE       Smbios handle already in use.
 253   @retval FALSE      Smbios handle is NOT used.
 254
 255 **/
 256 BOOLEAN
 257 EFIAPI
 258 CheckSmbiosHandleExistance (
 259   IN  LIST_ENTRY           *Head,
 260   IN  EFI_SMBIOS_HANDLE    Handle
 261   )
 262 {
 263   LIST_ENTRY              *Link;
 264   SMBIOS_HANDLE_ENTRY     *HandleEntry;
 265
 266   for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
 267     HandleEntry = SMBIOS_HANDLE_ENTRY_FROM_LINK(Link);
 268     if (HandleEntry->SmbiosHandle == Handle) {
 269       return TRUE;
 270     }
 271   }
 272
 273   return FALSE;
 274 }
 275
 276 /**
 277
 278   Get the max SmbiosHandle that could be use.
 279
 280   @param  This           The EFI_SMBIOS_PROTOCOL instance.
 281   @param  MaxHandle      The max handle that could be assigned to the SMBIOS record.
 282
 283 **/
 284 VOID
 285 EFIAPI
 286 GetMaxSmbiosHandle (
 287   IN CONST  EFI_SMBIOS_PROTOCOL   *This,
 288   IN OUT    EFI_SMBIOS_HANDLE     *MaxHandle
 289   )
 290 {
 291   if (This->MajorVersion == 2 && This->MinorVersion == 0) {
 292     *MaxHandle = 0xFFFE;
 293   } else {
 294     *MaxHandle = 0xFEFF;
 295   }
 296 }
 297
 298 /**
 299
 300   Get an SmbiosHandle that could use.
 301
 302   @param  This                   The EFI_SMBIOS_PROTOCOL instance.
 303   @param  SmbiosHandle           A unique handle will be assigned to the SMBIOS record.
 304
 305   @retval EFI_SUCCESS            Smbios handle got.
 306   @retval EFI_OUT_OF_RESOURCES   Smbios handle is NOT available.
 307
 308 **/
 309 EFI_STATUS
 310 EFIAPI
 311 GetAvailableSmbiosHandle (
 312   IN CONST EFI_SMBIOS_PROTOCOL   *This,
 313   IN OUT   EFI_SMBIOS_HANDLE     *Handle
 314   )
 315 {
 316   LIST_ENTRY              *Head;
 317   SMBIOS_INSTANCE         *Private;
 318   EFI_SMBIOS_HANDLE       MaxSmbiosHandle;
 319   EFI_SMBIOS_HANDLE       AvailableHandle;
 320
 321   GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
 322
 323   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 324   Head = &Private->AllocatedHandleListHead;
 325   for (AvailableHandle = 0; AvailableHandle < MaxSmbiosHandle; AvailableHandle++) {
 326     if (!CheckSmbiosHandleExistance(Head, AvailableHandle)) {
 327       *Handle = AvailableHandle;
 328       return EFI_SUCCESS;
 329     }
 330   }
 331
 332   return EFI_OUT_OF_RESOURCES;
 333 }
 334
 335
 336 /**
 337   Add an SMBIOS record.
 338
 339   @param  This                  The EFI_SMBIOS_PROTOCOL instance.
 340   @param  ProducerHandle        The handle of the controller or driver associated with the SMBIOS information. NULL
 341                                 means no handle.
 342   @param  SmbiosHandle          On entry, the handle of the SMBIOS record to add. If FFFEh, then a unique handle
 343                                 will be assigned to the SMBIOS record. If the SMBIOS handle is already in use,
 344                                 EFI_ALREADY_STARTED is returned and the SMBIOS record is not updated.
 345   @param  Record                The data for the fixed portion of the SMBIOS record. The format of the record is
 346                                 determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined
 347                                 by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or
 348                                 a set of null terminated strings and a null.
 349
 350   @retval EFI_SUCCESS           Record was added.
 351   @retval EFI_OUT_OF_RESOURCES  Record was not added due to lack of system resources.
 352   @retval EFI_ALREADY_STARTED   The SmbiosHandle passed in was already in use.
 353
 354 **/
 355 EFI_STATUS
 356 EFIAPI
 357 SmbiosAdd (
 358   IN CONST EFI_SMBIOS_PROTOCOL  *This,
 359   IN EFI_HANDLE                 ProducerHandle, OPTIONAL
 360   IN OUT EFI_SMBIOS_HANDLE      *SmbiosHandle,
 361   IN EFI_SMBIOS_TABLE_HEADER    *Record
 362   )
 363 {
 364   VOID                        *Raw;
 365   UINTN                       TotalSize;
 366   UINTN                       RecordSize;
 367   UINTN                       StructureSize;
 368   UINTN                       NumberOfStrings;
 369   EFI_STATUS                  Status;
 370   LIST_ENTRY                  *Head;
 371   SMBIOS_INSTANCE             *Private;
 372   EFI_SMBIOS_ENTRY            *SmbiosEntry;
 373   EFI_SMBIOS_HANDLE           MaxSmbiosHandle;
 374   SMBIOS_HANDLE_ENTRY         *HandleEntry;
 375   EFI_SMBIOS_RECORD_HEADER    *InternalRecord;
 376   BOOLEAN                     Smbios32BitTable;
 377   BOOLEAN                     Smbios64BitTable;
 378
 379   if (SmbiosHandle == NULL) {
 380     return EFI_INVALID_PARAMETER;
 381   }
 382
 383   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 384   //
 385   // Check whether SmbiosHandle is already in use
 386   //
 387   Head = &Private->AllocatedHandleListHead;
 388   if (*SmbiosHandle != SMBIOS_HANDLE_PI_RESERVED && CheckSmbiosHandleExistance(Head, *SmbiosHandle)) {
 389     return EFI_ALREADY_STARTED;
 390   }
 391
 392   //
 393   // when SmbiosHandle is 0xFFFE, an available handle will be assigned
 394   //
 395   if (*SmbiosHandle == SMBIOS_HANDLE_PI_RESERVED) {
 396     Status = GetAvailableSmbiosHandle(This, SmbiosHandle);
 397     if (EFI_ERROR(Status)) {
 398       return Status;
 399     }
 400   } else {
 401     //
 402     // Check this handle validity
 403     //
 404     GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
 405     if (*SmbiosHandle > MaxSmbiosHandle) {
 406       return EFI_INVALID_PARAMETER;
 407     }
 408   }
 409
 410   //
 411   // Calculate record size and string number
 412   //
 413   Status = GetSmbiosStructureSize(This, Record, &StructureSize, &NumberOfStrings);
 414   if (EFI_ERROR(Status)) {
 415     return Status;
 416   }
 417
 418   Smbios32BitTable = FALSE;
 419   Smbios64BitTable = FALSE;
 420   if ((This->MajorVersion < 0x3) ||
 421       ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT0) == BIT0))) {
 422     //
 423     // For SMBIOS 32-bit table, the length of the entire structure table (including all strings) must be reported
 424     // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
 425     // which is a WORD field limited to 65,535 bytes. So the max size of 32-bit table should not exceed 65,535 bytes.
 426     //
 427     if ((EntryPointStructure != NULL) &&
 428         (EntryPointStructure->TableLength + StructureSize > SMBIOS_TABLE_MAX_LENGTH)) {
 429       DEBUG ((EFI_D_INFO, "SmbiosAdd: Total length exceeds max 32-bit table length with type = %d size = 0x%x\n", Record->Type, StructureSize));
 430     } else {
 431       Smbios32BitTable = TRUE;
 432       DEBUG ((EFI_D_INFO, "SmbiosAdd: Smbios type %d with size 0x%x is added to 32-bit table\n", Record->Type, StructureSize));
 433     }
 434   }
 435
 436   //
 437   // For SMBIOS 3.0, Structure table maximum size in Entry Point structure is DWORD field limited to 0xFFFFFFFF bytes.
 438   //
 439   if ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT1) == BIT1)) {
 440     //
 441     // For SMBIOS 64-bit table, Structure table maximum size in SMBIOS 3.0 (64-bit) Entry Point
 442     // is a DWORD field limited to 0xFFFFFFFF bytes. So the max size of 64-bit table should not exceed 0xFFFFFFFF bytes.
 443     //
 444     if ((Smbios30EntryPointStructure != NULL) &&
 445         (Smbios30EntryPointStructure->TableMaximumSize + StructureSize > SMBIOS_3_0_TABLE_MAX_LENGTH)) {
 446       DEBUG ((EFI_D_INFO, "SmbiosAdd: Total length exceeds max 64-bit table length with type = %d size = 0x%x\n", Record->Type, StructureSize));
 447     } else {
 448       DEBUG ((EFI_D_INFO, "SmbiosAdd: Smbios type %d with size 0x%x is added to 64-bit table\n", Record->Type, StructureSize));
 449       Smbios64BitTable = TRUE;
 450     }
 451   }
 452
 453   if ((!Smbios32BitTable) && (!Smbios64BitTable)) {
 454     //
 455     // If both 32-bit and 64-bit table are not updated, quit
 456     //
 457     return EFI_OUT_OF_RESOURCES;
 458   }
 459
 460   //
 461   // Enter into critical section
 462   //
 463   Status = EfiAcquireLockOrFail (&Private->DataLock);
 464   if (EFI_ERROR (Status)) {
 465     return Status;
 466   }
 467
 468   RecordSize  = sizeof (EFI_SMBIOS_RECORD_HEADER) + StructureSize;
 469   TotalSize   = sizeof (EFI_SMBIOS_ENTRY) + RecordSize;
 470
 471   //
 472   // Allocate internal buffer
 473   //
 474   SmbiosEntry = AllocateZeroPool (TotalSize);
 475   if (SmbiosEntry == NULL) {
 476     EfiReleaseLock (&Private->DataLock);
 477     return EFI_OUT_OF_RESOURCES;
 478   }
 479   HandleEntry = AllocateZeroPool (sizeof(SMBIOS_HANDLE_ENTRY));
 480   if (HandleEntry == NULL) {
 481     EfiReleaseLock (&Private->DataLock);
 482     return EFI_OUT_OF_RESOURCES;
 483   }
 484
 485   //
 486   // Build Handle Entry and insert into linked list
 487   //
 488   HandleEntry->Signature     = SMBIOS_HANDLE_ENTRY_SIGNATURE;
 489   HandleEntry->SmbiosHandle  = *SmbiosHandle;
 490   InsertTailList(&Private->AllocatedHandleListHead, &HandleEntry->Link);
 491
 492   InternalRecord  = (EFI_SMBIOS_RECORD_HEADER *) (SmbiosEntry + 1);
 493   Raw     = (VOID *) (InternalRecord + 1);
 494
 495   //
 496   // Build internal record Header
 497   //
 498   InternalRecord->Version     = EFI_SMBIOS_RECORD_HEADER_VERSION;
 499   InternalRecord->HeaderSize  = (UINT16) sizeof (EFI_SMBIOS_RECORD_HEADER);
 500   InternalRecord->RecordSize  = RecordSize;
 501   InternalRecord->ProducerHandle = ProducerHandle;
 502   InternalRecord->NumberOfStrings = NumberOfStrings;
 503   //
 504   // Insert record into the internal linked list
 505   //
 506   SmbiosEntry->Signature    = EFI_SMBIOS_ENTRY_SIGNATURE;
 507   SmbiosEntry->RecordHeader = InternalRecord;
 508   SmbiosEntry->RecordSize   = TotalSize;
 509   SmbiosEntry->Smbios32BitTable = Smbios32BitTable;
 510   SmbiosEntry->Smbios64BitTable = Smbios64BitTable;
 511   InsertTailList (&Private->DataListHead, &SmbiosEntry->Link);
 512
 513   CopyMem (Raw, Record, StructureSize);
 514   ((EFI_SMBIOS_TABLE_HEADER*)Raw)->Handle = *SmbiosHandle;
 515
 516   //
 517   // Some UEFI drivers (such as network) need some information in SMBIOS table.
 518   // Here we create SMBIOS table and publish it in
 519   // configuration table, so other UEFI drivers can get SMBIOS table from
 520   // configuration table without depending on PI SMBIOS protocol.
 521   //
 522   SmbiosTableConstruction (Smbios32BitTable, Smbios64BitTable);
 523
 524   //
 525   // Leave critical section
 526   //
 527   EfiReleaseLock (&Private->DataLock);
 528   return EFI_SUCCESS;
 529 }
 530
 531 /**
 532   Update the string associated with an existing SMBIOS record.
 533
 534   @param  This                  The EFI_SMBIOS_PROTOCOL instance.
 535   @param  SmbiosHandle          SMBIOS Handle of structure that will have its string updated.
 536   @param  StringNumber          The non-zero string number of the string to update
 537   @param  String                Update the StringNumber string with String.
 538
 539   @retval EFI_SUCCESS           SmbiosHandle had its StringNumber String updated.
 540   @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist.
 541   @retval EFI_UNSUPPORTED       String was not added because it is longer than the SMBIOS Table supports.
 542   @retval EFI_NOT_FOUND         The StringNumber.is not valid for this SMBIOS record.
 543
 544 **/
 545 EFI_STATUS
 546 EFIAPI
 547 SmbiosUpdateString (
 548   IN CONST EFI_SMBIOS_PROTOCOL      *This,
 549   IN EFI_SMBIOS_HANDLE              *SmbiosHandle,
 550   IN UINTN                          *StringNumber,
 551   IN CHAR8                          *String
 552   )
 553 {
 554   UINTN                     InputStrLen;
 555   UINTN                     TargetStrLen;
 556   UINTN                     StrIndex;
 557   UINTN                     TargetStrOffset;
 558   UINTN                     NewEntrySize;
 559   CHAR8                     *StrStart;
 560   VOID                      *Raw;
 561   LIST_ENTRY                *Link;
 562   LIST_ENTRY                *Head;
 563   EFI_STATUS                Status;
 564   SMBIOS_INSTANCE           *Private;
 565   EFI_SMBIOS_ENTRY          *SmbiosEntry;
 566   EFI_SMBIOS_ENTRY          *ResizedSmbiosEntry;
 567   EFI_SMBIOS_HANDLE         MaxSmbiosHandle;
 568   EFI_SMBIOS_TABLE_HEADER   *Record;
 569   EFI_SMBIOS_RECORD_HEADER  *InternalRecord;
 570
 571   //
 572   // Check args validity
 573   //
 574   GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
 575
 576   if (*SmbiosHandle > MaxSmbiosHandle) {
 577     return EFI_INVALID_PARAMETER;
 578   }
 579
 580   if (String == NULL) {
 581     return EFI_ABORTED;
 582   }
 583
 584   if (*StringNumber == 0) {
 585     return EFI_NOT_FOUND;
 586   }
 587
 588   InputStrLen = AsciiStrLen(String);
 589
 590   if (This->MajorVersion < 2 || (This->MajorVersion == 2 && This->MinorVersion < 7)) {
 591     if (InputStrLen > SMBIOS_STRING_MAX_LENGTH) {
 592       return EFI_UNSUPPORTED;
 593     }
 594   } else if (This->MajorVersion < 3) {
 595     //
 596     // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.
 597     // However, the length of the entire structure table (including all strings) must be reported
 598     // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
 599     // which is a WORD field limited to 65,535 bytes.
 600     //
 601     if (InputStrLen > SMBIOS_TABLE_MAX_LENGTH) {
 602       return EFI_UNSUPPORTED;
 603     }
 604   } else {
 605     if (InputStrLen > SMBIOS_3_0_TABLE_MAX_LENGTH) {
 606       //
 607       // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.
 608       // The input string length should not exceed 0xFFFFFFFF bytes.
 609       //
 610       return EFI_UNSUPPORTED;
 611     }
 612   }
 613
 614   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 615   //
 616   // Enter into critical section
 617   //
 618   Status = EfiAcquireLockOrFail (&Private->DataLock);
 619   if (EFI_ERROR (Status)) {
 620     return Status;
 621   }
 622
 623   Head = &Private->DataListHead;
 624   for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
 625     SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
 626     Record = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
 627
 628     if (Record->Handle == *SmbiosHandle) {
 629       //
 630       // Find out the specified SMBIOS record
 631       //
 632       if (*StringNumber > SmbiosEntry->RecordHeader->NumberOfStrings) {
 633         EfiReleaseLock (&Private->DataLock);
 634         return EFI_NOT_FOUND;
 635       }
 636       //
 637       // Point to unformed string section
 638       //
 639       StrStart = (CHAR8 *) Record + Record->Length;
 640
 641       for (StrIndex = 1, TargetStrOffset = 0; StrIndex < *StringNumber; StrStart++, TargetStrOffset++) {
 642         //
 643         // A string ends in 00h
 644         //
 645         if (*StrStart == 0) {
 646           StrIndex++;
 647         }
 648
 649         //
 650         // String section ends in double-null (0000h)
 651         //
 652         if (*StrStart == 0 && *(StrStart + 1) == 0) {
 653           EfiReleaseLock (&Private->DataLock);
 654           return EFI_NOT_FOUND;
 655         }
 656       }
 657
 658       if (*StrStart == 0) {
 659         StrStart++;
 660         TargetStrOffset++;
 661       }
 662
 663       //
 664       // Now we get the string target
 665       //
 666       TargetStrLen = AsciiStrLen(StrStart);
 667       if (InputStrLen == TargetStrLen) {
 668         AsciiStrCpyS(StrStart, TargetStrLen + 1, String);
 669         //
 670         // Some UEFI drivers (such as network) need some information in SMBIOS table.
 671         // Here we create SMBIOS table and publish it in
 672         // configuration table, so other UEFI drivers can get SMBIOS table from
 673         // configuration table without depending on PI SMBIOS protocol.
 674         //
 675         SmbiosTableConstruction (SmbiosEntry->Smbios32BitTable, SmbiosEntry->Smbios64BitTable);
 676         EfiReleaseLock (&Private->DataLock);
 677         return EFI_SUCCESS;
 678       }
 679
 680       SmbiosEntry->Smbios32BitTable = FALSE;
 681       SmbiosEntry->Smbios64BitTable = FALSE;
 682       if ((This->MajorVersion < 0x3) ||
 683           ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT0) == BIT0))) {
 684         //
 685         // 32-bit table is produced, check the valid length.
 686         //
 687         if ((EntryPointStructure != NULL) &&
 688             (EntryPointStructure->TableLength + InputStrLen - TargetStrLen > SMBIOS_TABLE_MAX_LENGTH)) {
 689           //
 690           // The length of the entire structure table (including all strings) must be reported
 691           // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
 692           // which is a WORD field limited to 65,535 bytes.
 693           //
 694           DEBUG ((EFI_D_INFO, "SmbiosUpdateString: Total length exceeds max 32-bit table length\n"));
 695         } else {
 696           DEBUG ((EFI_D_INFO, "SmbiosUpdateString: New smbios record add to 32-bit table\n"));
 697           SmbiosEntry->Smbios32BitTable = TRUE;
 698         }
 699       }
 700
 701       if ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT1) == BIT1)) {
 702         //
 703         // 64-bit table is produced, check the valid length.
 704         //
 705         if ((Smbios30EntryPointStructure != NULL) &&
 706             (Smbios30EntryPointStructure->TableMaximumSize + InputStrLen - TargetStrLen > SMBIOS_3_0_TABLE_MAX_LENGTH)) {
 707           DEBUG ((EFI_D_INFO, "SmbiosUpdateString: Total length exceeds max 64-bit table length\n"));
 708         } else {
 709           DEBUG ((EFI_D_INFO, "SmbiosUpdateString: New smbios record add to 64-bit table\n"));
 710           SmbiosEntry->Smbios64BitTable = TRUE;
 711         }
 712       }
 713
 714       if ((!SmbiosEntry->Smbios32BitTable) && (!SmbiosEntry->Smbios64BitTable)) {
 715         EfiReleaseLock (&Private->DataLock);
 716         return EFI_UNSUPPORTED;
 717       }
 718
 719       //
 720       // Original string buffer size is not exactly match input string length.
 721       // Re-allocate buffer is needed.
 722       //
 723       NewEntrySize = SmbiosEntry->RecordSize + InputStrLen - TargetStrLen;
 724       ResizedSmbiosEntry = AllocateZeroPool (NewEntrySize);
 725
 726       if (ResizedSmbiosEntry == NULL) {
 727         EfiReleaseLock (&Private->DataLock);
 728         return EFI_OUT_OF_RESOURCES;
 729       }
 730
 731       InternalRecord  = (EFI_SMBIOS_RECORD_HEADER *) (ResizedSmbiosEntry + 1);
 732       Raw     = (VOID *) (InternalRecord + 1);
 733
 734       //
 735       // Build internal record Header
 736       //
 737       InternalRecord->Version     = EFI_SMBIOS_RECORD_HEADER_VERSION;
 738       InternalRecord->HeaderSize  = (UINT16) sizeof (EFI_SMBIOS_RECORD_HEADER);
 739       InternalRecord->RecordSize  = SmbiosEntry->RecordHeader->RecordSize + InputStrLen - TargetStrLen;
 740       InternalRecord->ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
 741       InternalRecord->NumberOfStrings = SmbiosEntry->RecordHeader->NumberOfStrings;
 742
 743       //
 744       // Copy SMBIOS structure and optional strings.
 745       //
 746       CopyMem (Raw, SmbiosEntry->RecordHeader + 1, Record->Length + TargetStrOffset);
 747       CopyMem ((VOID*)((UINTN)Raw + Record->Length + TargetStrOffset), String, InputStrLen + 1);
 748       CopyMem ((CHAR8*)((UINTN)Raw + Record->Length + TargetStrOffset + InputStrLen + 1),
 749                (CHAR8*)Record + Record->Length + TargetStrOffset + TargetStrLen + 1,
 750                SmbiosEntry->RecordHeader->RecordSize - sizeof (EFI_SMBIOS_RECORD_HEADER) - Record->Length - TargetStrOffset - TargetStrLen - 1);
 751
 752       //
 753       // Insert new record
 754       //
 755       ResizedSmbiosEntry->Signature    = EFI_SMBIOS_ENTRY_SIGNATURE;
 756       ResizedSmbiosEntry->RecordHeader = InternalRecord;
 757       ResizedSmbiosEntry->RecordSize   = NewEntrySize;
 758       ResizedSmbiosEntry->Smbios32BitTable = SmbiosEntry->Smbios32BitTable;
 759       ResizedSmbiosEntry->Smbios64BitTable = SmbiosEntry->Smbios64BitTable;
 760       InsertTailList (Link->ForwardLink, &ResizedSmbiosEntry->Link);
 761
 762       //
 763       // Remove old record
 764       //
 765       RemoveEntryList(Link);
 766       FreePool(SmbiosEntry);
 767       //
 768       // Some UEFI drivers (such as network) need some information in SMBIOS table.
 769       // Here we create SMBIOS table and publish it in
 770       // configuration table, so other UEFI drivers can get SMBIOS table from
 771       // configuration table without depending on PI SMBIOS protocol.
 772       //
 773       SmbiosTableConstruction (ResizedSmbiosEntry->Smbios32BitTable, ResizedSmbiosEntry->Smbios64BitTable);
 774       EfiReleaseLock (&Private->DataLock);
 775       return EFI_SUCCESS;
 776     }
 777   }
 778
 779   EfiReleaseLock (&Private->DataLock);
 780   return EFI_INVALID_PARAMETER;
 781 }
 782
 783 /**
 784   Remove an SMBIOS record.
 785
 786   @param  This                  The EFI_SMBIOS_PROTOCOL instance.
 787   @param  SmbiosHandle          The handle of the SMBIOS record to remove.
 788
 789   @retval EFI_SUCCESS           SMBIOS record was removed.
 790   @retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record.
 791
 792 **/
 793 EFI_STATUS
 794 EFIAPI
 795 SmbiosRemove (
 796   IN CONST EFI_SMBIOS_PROTOCOL   *This,
 797   IN EFI_SMBIOS_HANDLE           SmbiosHandle
 798   )
 799 {
 800   LIST_ENTRY                 *Link;
 801   LIST_ENTRY                 *Head;
 802   EFI_STATUS                 Status;
 803   EFI_SMBIOS_HANDLE          MaxSmbiosHandle;
 804   SMBIOS_INSTANCE            *Private;
 805   EFI_SMBIOS_ENTRY           *SmbiosEntry;
 806   SMBIOS_HANDLE_ENTRY        *HandleEntry;
 807   EFI_SMBIOS_TABLE_HEADER    *Record;
 808
 809   //
 810   // Check args validity
 811   //
 812   GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
 813
 814   if (SmbiosHandle > MaxSmbiosHandle) {
 815     return EFI_INVALID_PARAMETER;
 816   }
 817
 818   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 819   //
 820   // Enter into critical section
 821   //
 822   Status = EfiAcquireLockOrFail (&Private->DataLock);
 823   if (EFI_ERROR (Status)) {
 824     return Status;
 825   }
 826
 827   Head = &Private->DataListHead;
 828   for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
 829     SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
 830     Record = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
 831     if (Record->Handle == SmbiosHandle) {
 832       //
 833       // Remove specified smobios record from DataList
 834       //
 835       RemoveEntryList(Link);
 836       //
 837       // Remove this handle from AllocatedHandleList
 838       //
 839       Head = &Private->AllocatedHandleListHead;
 840       for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
 841         HandleEntry = SMBIOS_HANDLE_ENTRY_FROM_LINK(Link);
 842         if (HandleEntry->SmbiosHandle == SmbiosHandle) {
 843           RemoveEntryList(Link);
 844           FreePool(HandleEntry);
 845           break;
 846         }
 847       }
 848       //
 849       // Some UEFI drivers (such as network) need some information in SMBIOS table.
 850       // Here we create SMBIOS table and publish it in
 851       // configuration table, so other UEFI drivers can get SMBIOS table from
 852       // configuration table without depending on PI SMBIOS protocol.
 853       //
 854       if (SmbiosEntry->Smbios32BitTable) {
 855         DEBUG ((EFI_D_INFO, "SmbiosRemove: remove from 32-bit table\n"));
 856       }
 857       if (SmbiosEntry->Smbios64BitTable) {
 858         DEBUG ((EFI_D_INFO, "SmbiosRemove: remove from 64-bit table\n"));
 859       }
 860       //
 861       // Update the whole SMBIOS table again based on which table the removed SMBIOS record is in.
 862       //
 863       SmbiosTableConstruction (SmbiosEntry->Smbios32BitTable, SmbiosEntry->Smbios64BitTable);
 864       FreePool(SmbiosEntry);
 865       EfiReleaseLock (&Private->DataLock);
 866       return EFI_SUCCESS;
 867     }
 868   }
 869
 870   //
 871   // Leave critical section
 872   //
 873   EfiReleaseLock (&Private->DataLock);
 874   return EFI_INVALID_PARAMETER;
 875
 876 }
 877
 878 /**
 879   Allow the caller to discover all or some of the SMBIOS records.
 880
 881   @param  This                  The EFI_SMBIOS_PROTOCOL instance.
 882   @param  SmbiosHandle          On entry, points to the previous handle of the SMBIOS record. On exit, points to the
 883                                 next SMBIOS record handle. If it is FFFEh on entry, then the first SMBIOS record
 884                                 handle will be returned. If it returns FFFEh on exit, then there are no more SMBIOS records.
 885   @param  Type                  On entry it means return the next SMBIOS record of type Type. If a NULL is passed in
 886                                 this functionally it ignored. Type is not modified by the GetNext() function.
 887   @param  Record                On exit, points to the SMBIOS Record consisting of the formatted area followed by
 888                                 the unformatted area. The unformatted area optionally contains text strings.
 889   @param  ProducerHandle        On exit, points to the ProducerHandle registered by Add(). If no ProducerHandle was passed into Add() NULL is returned.
 890                                 If a NULL pointer is passed in no data will be returned
 891
 892   @retval EFI_SUCCESS           SMBIOS record information was successfully returned in Record.
 893   @retval EFI_NOT_FOUND         The SMBIOS record with SmbiosHandle was the last available record.
 894
 895 **/
 896 EFI_STATUS
 897 EFIAPI
 898 SmbiosGetNext (
 899   IN CONST EFI_SMBIOS_PROTOCOL      *This,
 900   IN OUT EFI_SMBIOS_HANDLE          *SmbiosHandle,
 901   IN EFI_SMBIOS_TYPE                *Type,          OPTIONAL
 902   OUT EFI_SMBIOS_TABLE_HEADER       **Record,
 903   OUT EFI_HANDLE                    *ProducerHandle OPTIONAL
 904   )
 905 {
 906   BOOLEAN                  StartPointFound;
 907   LIST_ENTRY               *Link;
 908   LIST_ENTRY               *Head;
 909   SMBIOS_INSTANCE          *Private;
 910   EFI_SMBIOS_ENTRY         *SmbiosEntry;
 911   EFI_SMBIOS_TABLE_HEADER  *SmbiosTableHeader;
 912
 913   if (SmbiosHandle == NULL) {
 914     return EFI_INVALID_PARAMETER;
 915   }
 916
 917   StartPointFound = FALSE;
 918   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 919   Head = &Private->DataListHead;
 920   for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
 921     SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
 922     SmbiosTableHeader = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
 923
 924     //
 925     // If SmbiosHandle is 0xFFFE, the first matched SMBIOS record handle will be returned
 926     //
 927     if (*SmbiosHandle == SMBIOS_HANDLE_PI_RESERVED) {
 928       if ((Type != NULL) && (*Type != SmbiosTableHeader->Type)) {
 929         continue;
 930       }
 931
 932       *SmbiosHandle = SmbiosTableHeader->Handle;
 933       *Record =SmbiosTableHeader;
 934       if (ProducerHandle != NULL) {
 935         *ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
 936       }
 937       return EFI_SUCCESS;
 938     }
 939
 940     //
 941     // Start this round search from the next SMBIOS handle
 942     //
 943     if (!StartPointFound && (*SmbiosHandle == SmbiosTableHeader->Handle)) {
 944       StartPointFound = TRUE;
 945       continue;
 946     }
 947
 948     if (StartPointFound) {
 949       if ((Type != NULL) && (*Type != SmbiosTableHeader->Type)) {
 950         continue;
 951       }
 952
 953       *SmbiosHandle = SmbiosTableHeader->Handle;
 954       *Record = SmbiosTableHeader;
 955       if (ProducerHandle != NULL) {
 956         *ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
 957       }
 958
 959       return EFI_SUCCESS;
 960     }
 961   }
 962
 963   *SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
 964   return EFI_NOT_FOUND;
 965
 966 }
 967
 968 /**
 969   Allow the caller to discover all of the SMBIOS records.
 970
 971   @param  This                  The EFI_SMBIOS_PROTOCOL instance.
 972   @param  CurrentSmbiosEntry    On exit, points to the SMBIOS entry on the list which includes the returned SMBIOS record information.
 973                                 If *CurrentSmbiosEntry is NULL on entry, then the first SMBIOS entry on the list will be returned.
 974   @param  Record                On exit, points to the SMBIOS Record consisting of the formatted area followed by
 975                                 the unformatted area. The unformatted area optionally contains text strings.
 976
 977   @retval EFI_SUCCESS           SMBIOS record information was successfully returned in Record.
 978                                 *CurrentSmbiosEntry points to the SMBIOS entry which includes the returned SMBIOS record information.
 979   @retval EFI_NOT_FOUND         There is no more SMBIOS entry.
 980
 981 **/
 982 EFI_STATUS
 983 EFIAPI
 984 GetNextSmbiosRecord (
 985   IN CONST EFI_SMBIOS_PROTOCOL         *This,
 986   IN OUT EFI_SMBIOS_ENTRY              **CurrentSmbiosEntry,
 987   OUT EFI_SMBIOS_TABLE_HEADER          **Record
 988   )
 989 {
 990   LIST_ENTRY               *Link;
 991   LIST_ENTRY               *Head;
 992   SMBIOS_INSTANCE          *Private;
 993   EFI_SMBIOS_ENTRY         *SmbiosEntry;
 994   EFI_SMBIOS_TABLE_HEADER  *SmbiosTableHeader;
 995
 996   Private = SMBIOS_INSTANCE_FROM_THIS (This);
 997   if (*CurrentSmbiosEntry == NULL) {
 998     //
 999     // Get the beginning of SMBIOS entry.
1000     //
1001     Head = &Private->DataListHead;
1002   } else {
1003     //
1004     // Get previous SMBIOS entry and make it as start point.
1005     //
1006     Head = &(*CurrentSmbiosEntry)->Link;
1007   }
1008
1009   Link  = Head->ForwardLink;
1010
1011   if (Link == &Private->DataListHead) {
1012     //
1013     // If no more SMBIOS entry in the list, return not found.
1014     //
1015     return EFI_NOT_FOUND;
1016   }
1017
1018   SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
1019   SmbiosTableHeader = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
1020   *Record = SmbiosTableHeader;
1021   *CurrentSmbiosEntry = SmbiosEntry;
1022   return EFI_SUCCESS;
1023 }
1024
1025 /**
1026   Assembles SMBIOS table from the SMBIOS protocol. Produce Table
1027   Entry Point and return the pointer to it.
1028
1029   @param  TableEntryPointStructure   On exit, points to the SMBIOS entrypoint structure.
1030
1031   @retval EFI_SUCCESS                Structure created sucessfully.
1032   @retval EFI_OUT_OF_RESOURCES       No enough memory.
1033
1034 **/
1035 EFI_STATUS
1036 EFIAPI
1037 SmbiosCreateTable (
1038   OUT VOID    **TableEntryPointStructure
1039   )
1040 {
1041   UINT8                           *BufferPointer;
1042   UINTN                           RecordSize;
1043   UINTN                           NumOfStr;
1044   EFI_STATUS                      Status;
1045   EFI_SMBIOS_HANDLE               SmbiosHandle;
1046   EFI_SMBIOS_PROTOCOL             *SmbiosProtocol;
1047   EFI_PHYSICAL_ADDRESS            PhysicalAddress;
1048   EFI_SMBIOS_TABLE_HEADER         *SmbiosRecord;
1049   EFI_SMBIOS_TABLE_END_STRUCTURE  EndStructure;
1050   EFI_SMBIOS_ENTRY                *CurrentSmbiosEntry;
1051
1052   Status            = EFI_SUCCESS;
1053   BufferPointer     = NULL;
1054
1055   if (EntryPointStructure == NULL) {
1056     //
1057     // Initialize the EntryPointStructure with initial values.
1058     // It should be done only once.
1059     // Allocate memory (below 4GB).
1060     //
1061     DEBUG ((EFI_D_INFO, "SmbiosCreateTable: Initialize 32-bit entry point structure\n"));
1062     EntryPointStructureData.MajorVersion  = mPrivateData.Smbios.MajorVersion;
1063     EntryPointStructureData.MinorVersion  = mPrivateData.Smbios.MinorVersion;
1064     EntryPointStructureData.SmbiosBcdRevision = (UINT8) ((PcdGet16 (PcdSmbiosVersion) >> 4) & 0xf0) | (UINT8) (PcdGet16 (PcdSmbiosVersion) & 0x0f);
1065     PhysicalAddress = 0xffffffff;
1066     Status = gBS->AllocatePages (
1067                     AllocateMaxAddress,
1068                     EfiRuntimeServicesData,
1069                     EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_ENTRY_POINT)),
1070                     &PhysicalAddress
1071                     );
1072     if (EFI_ERROR (Status)) {
1073       DEBUG ((EFI_D_ERROR, "SmbiosCreateTable () could not allocate EntryPointStructure < 4GB\n"));
1074       Status = gBS->AllocatePages (
1075                       AllocateAnyPages,
1076                       EfiRuntimeServicesData,
1077                       EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_ENTRY_POINT)),
1078                       &PhysicalAddress
1079                       );
1080      if (EFI_ERROR (Status)) {
1081         return EFI_OUT_OF_RESOURCES;
1082       }
1083     }
1084
1085     EntryPointStructure = (SMBIOS_TABLE_ENTRY_POINT *) (UINTN) PhysicalAddress;
1086
1087     CopyMem (
1088       EntryPointStructure,
1089       &EntryPointStructureData,
1090       sizeof (SMBIOS_TABLE_ENTRY_POINT)
1091       );
1092   }
1093
1094   //
1095   // Get Smbios protocol to traverse SMBIOS records.
1096   //
1097   SmbiosProtocol = &mPrivateData.Smbios;
1098
1099   //
1100   // Make some statistics about all the structures
1101   //
1102   EntryPointStructure->NumberOfSmbiosStructures = 0;
1103   EntryPointStructure->TableLength              = 0;
1104   EntryPointStructure->MaxStructureSize         = 0;
1105
1106   //
1107   // Calculate EPS Table Length
1108   //
1109   CurrentSmbiosEntry = NULL;
1110   do {
1111     Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1112
1113     if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios32BitTable)) {
1114       GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1115       //
1116       // Record NumberOfSmbiosStructures, TableLength and MaxStructureSize
1117       //
1118       EntryPointStructure->NumberOfSmbiosStructures++;
1119       EntryPointStructure->TableLength = (UINT16) (EntryPointStructure->TableLength + RecordSize);
1120       if (RecordSize > EntryPointStructure->MaxStructureSize) {
1121         EntryPointStructure->MaxStructureSize = (UINT16) RecordSize;
1122       }
1123     }
1124   } while (!EFI_ERROR(Status));
1125
1126   //
1127   // Create End-Of-Table structure
1128   //
1129   GetMaxSmbiosHandle(SmbiosProtocol, &SmbiosHandle);
1130   EndStructure.Header.Type = EFI_SMBIOS_TYPE_END_OF_TABLE;
1131   EndStructure.Header.Length = (UINT8) sizeof (EFI_SMBIOS_TABLE_HEADER);
1132   EndStructure.Header.Handle = SmbiosHandle;
1133   EndStructure.Tailing[0] = 0;
1134   EndStructure.Tailing[1] = 0;
1135   EntryPointStructure->NumberOfSmbiosStructures++;
1136   EntryPointStructure->TableLength = (UINT16) (EntryPointStructure->TableLength + sizeof (EndStructure));
1137   if (sizeof (EndStructure) > EntryPointStructure->MaxStructureSize) {
1138     EntryPointStructure->MaxStructureSize = (UINT16) sizeof (EndStructure);
1139   }
1140
1141   if ((UINTN) EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength) > mPreAllocatedPages) {
1142     //
1143     // If new SMBIOS table size exceeds the previous allocated page,
1144     // it is time to re-allocate memory (below 4GB).
1145     //
1146     DEBUG ((EFI_D_ERROR, "SmbiosCreateTable() re-allocate SMBIOS 32-bit table\n"));
1147     if (EntryPointStructure->TableAddress != 0) {
1148       //
1149       // Free the previous allocated page
1150       //
1151       FreePages (
1152             (VOID*)(UINTN)EntryPointStructure->TableAddress,
1153             mPreAllocatedPages
1154             );
1155       EntryPointStructure->TableAddress = 0;
1156       mPreAllocatedPages = 0;
1157     }
1158
1159     PhysicalAddress = 0xffffffff;
1160     Status = gBS->AllocatePages (
1161                     AllocateMaxAddress,
1162                     EfiRuntimeServicesData,
1163                     EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength),
1164                     &PhysicalAddress
1165                     );
1166     if (EFI_ERROR (Status)) {
1167       DEBUG ((EFI_D_ERROR, "SmbiosCreateTable() could not allocate SMBIOS table < 4GB\n"));
1168       EntryPointStructure->TableAddress = 0;
1169       return EFI_OUT_OF_RESOURCES;
1170     } else {
1171       EntryPointStructure->TableAddress = (UINT32) PhysicalAddress;
1172       mPreAllocatedPages = EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength);
1173     }
1174   }
1175
1176   //
1177   // Assemble the tables
1178   //
1179   ASSERT (EntryPointStructure->TableAddress != 0);
1180   BufferPointer = (UINT8 *) (UINTN) EntryPointStructure->TableAddress;
1181   CurrentSmbiosEntry = NULL;
1182   do {
1183     Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1184
1185     if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios32BitTable)) {
1186       GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1187       CopyMem (BufferPointer, SmbiosRecord, RecordSize);
1188       BufferPointer = BufferPointer + RecordSize;
1189     }
1190   } while (!EFI_ERROR(Status));
1191
1192   //
1193   // Assemble End-Of-Table structure
1194   //
1195   CopyMem (BufferPointer, &EndStructure, sizeof (EndStructure));
1196
1197   //
1198   // Fixup checksums in the Entry Point Structure
1199   //
1200   EntryPointStructure->IntermediateChecksum = 0;
1201   EntryPointStructure->EntryPointStructureChecksum = 0;
1202
1203   EntryPointStructure->IntermediateChecksum =
1204     CalculateCheckSum8 ((UINT8 *) EntryPointStructure + 0x10, EntryPointStructure->EntryPointLength - 0x10);
1205   EntryPointStructure->EntryPointStructureChecksum =
1206     CalculateCheckSum8 ((UINT8 *) EntryPointStructure, EntryPointStructure->EntryPointLength);
1207
1208   //
1209   // Returns the pointer
1210   //
1211   *TableEntryPointStructure = EntryPointStructure;
1212
1213   return EFI_SUCCESS;
1214 }
1215
1216 /**
1217   Assembles SMBIOS 64-bit table from the SMBIOS protocol. Produce Table
1218   Entry Point and return the pointer to it.
1219
1220   @param  TableEntryPointStructure   On exit, points to the SMBIOS entrypoint structure.
1221
1222   @retval EFI_SUCCESS                Structure created sucessfully.
1223   @retval EFI_OUT_OF_RESOURCES       No enough memory.
1224
1225 **/
1226 EFI_STATUS
1227 EFIAPI
1228 SmbiosCreate64BitTable (
1229   OUT VOID    **TableEntryPointStructure
1230   )
1231 {
1232   UINT8                           *BufferPointer;
1233   UINTN                           RecordSize;
1234   UINTN                           NumOfStr;
1235   EFI_STATUS                      Status;
1236   EFI_SMBIOS_HANDLE               SmbiosHandle;
1237   EFI_SMBIOS_PROTOCOL             *SmbiosProtocol;
1238   EFI_PHYSICAL_ADDRESS            PhysicalAddress;
1239   EFI_SMBIOS_TABLE_HEADER         *SmbiosRecord;
1240   EFI_SMBIOS_TABLE_END_STRUCTURE  EndStructure;
1241   EFI_SMBIOS_ENTRY                *CurrentSmbiosEntry;
1242
1243   Status            = EFI_SUCCESS;
1244   BufferPointer     = NULL;
1245
1246   if (Smbios30EntryPointStructure == NULL) {
1247     //
1248     // Initialize the Smbios30EntryPointStructure with initial values.
1249     // It should be done only once.
1250     // Allocate memory at any address.
1251     //
1252     DEBUG ((EFI_D_INFO, "SmbiosCreateTable: Initialize 64-bit entry point structure\n"));
1253     Smbios30EntryPointStructureData.MajorVersion  = mPrivateData.Smbios.MajorVersion;
1254     Smbios30EntryPointStructureData.MinorVersion  = mPrivateData.Smbios.MinorVersion;
1255     Smbios30EntryPointStructureData.DocRev        = PcdGet8 (PcdSmbiosDocRev);
1256     Status = gBS->AllocatePages (
1257                     AllocateAnyPages,
1258                     EfiRuntimeServicesData,
1259                     EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_3_0_ENTRY_POINT)),
1260                     &PhysicalAddress
1261                     );
1262     if (EFI_ERROR (Status)) {
1263       DEBUG ((EFI_D_ERROR, "SmbiosCreate64BitTable() could not allocate Smbios30EntryPointStructure\n"));
1264       return EFI_OUT_OF_RESOURCES;
1265     }
1266
1267     Smbios30EntryPointStructure = (SMBIOS_TABLE_3_0_ENTRY_POINT *) (UINTN) PhysicalAddress;
1268
1269     CopyMem (
1270       Smbios30EntryPointStructure,
1271       &Smbios30EntryPointStructureData,
1272       sizeof (SMBIOS_TABLE_3_0_ENTRY_POINT)
1273       );
1274   }
1275
1276   //
1277   // Get Smbios protocol to traverse SMBIOS records.
1278   //
1279   SmbiosProtocol = &mPrivateData.Smbios;
1280   Smbios30EntryPointStructure->TableMaximumSize = 0;
1281
1282   //
1283   // Calculate EPS Table Length
1284   //
1285   CurrentSmbiosEntry = NULL;
1286   do {
1287     Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1288
1289     if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios64BitTable)) {
1290       GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1291       //
1292       // Record TableMaximumSize
1293       //
1294       Smbios30EntryPointStructure->TableMaximumSize = (UINT32) (Smbios30EntryPointStructure->TableMaximumSize + RecordSize);
1295     }
1296   } while (!EFI_ERROR(Status));
1297
1298   //
1299   // Create End-Of-Table structure
1300   //
1301   GetMaxSmbiosHandle(SmbiosProtocol, &SmbiosHandle);
1302   EndStructure.Header.Type = EFI_SMBIOS_TYPE_END_OF_TABLE;
1303   EndStructure.Header.Length = (UINT8) sizeof (EFI_SMBIOS_TABLE_HEADER);
1304   EndStructure.Header.Handle = SmbiosHandle;
1305   EndStructure.Tailing[0] = 0;
1306   EndStructure.Tailing[1] = 0;
1307   Smbios30EntryPointStructure->TableMaximumSize = (UINT32) (Smbios30EntryPointStructure->TableMaximumSize + sizeof (EndStructure));
1308
1309   if ((UINTN) EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize) > mPre64BitAllocatedPages) {
1310     //
1311     // If new SMBIOS table size exceeds the previous allocated page,
1312     // it is time to re-allocate memory at anywhere.
1313     //
1314     DEBUG ((EFI_D_ERROR, "SmbiosCreate64BitTable() re-allocate SMBIOS 64-bit table\n"));
1315     if (Smbios30EntryPointStructure->TableAddress != 0) {
1316       //
1317       // Free the previous allocated page
1318       //
1319       FreePages (
1320             (VOID*)(UINTN)Smbios30EntryPointStructure->TableAddress,
1321             mPre64BitAllocatedPages
1322             );
1323       Smbios30EntryPointStructure->TableAddress = 0;
1324       mPre64BitAllocatedPages = 0;
1325     }
1326
1327     Status = gBS->AllocatePages (
1328                     AllocateAnyPages,
1329                     EfiRuntimeServicesData,
1330                     EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize),
1331                     &PhysicalAddress
1332                     );
1333     if (EFI_ERROR (Status)) {
1334       DEBUG ((EFI_D_ERROR, "SmbiosCreateTable() could not allocate SMBIOS 64-bit table\n"));
1335       Smbios30EntryPointStructure->TableAddress = 0;
1336       return EFI_OUT_OF_RESOURCES;
1337     } else {
1338       Smbios30EntryPointStructure->TableAddress = PhysicalAddress;
1339       mPre64BitAllocatedPages = EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize);
1340     }
1341   }
1342
1343   //
1344   // Assemble the tables
1345   //
1346   ASSERT (Smbios30EntryPointStructure->TableAddress != 0);
1347   BufferPointer = (UINT8 *) (UINTN) Smbios30EntryPointStructure->TableAddress;
1348   CurrentSmbiosEntry = NULL;
1349   do {
1350     Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1351
1352     if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios64BitTable)) {
1353       //
1354       // This record can be added to 64-bit table
1355       //
1356       GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1357       CopyMem (BufferPointer, SmbiosRecord, RecordSize);
1358       BufferPointer = BufferPointer + RecordSize;
1359     }
1360   } while (!EFI_ERROR(Status));
1361
1362   //
1363   // Assemble End-Of-Table structure
1364   //
1365   CopyMem (BufferPointer, &EndStructure, sizeof (EndStructure));
1366
1367   //
1368   // Fixup checksums in the Entry Point Structure
1369   //
1370   Smbios30EntryPointStructure->EntryPointStructureChecksum = 0;
1371   Smbios30EntryPointStructure->EntryPointStructureChecksum =
1372     CalculateCheckSum8 ((UINT8 *) Smbios30EntryPointStructure, Smbios30EntryPointStructure->EntryPointLength);
1373
1374   //
1375   // Returns the pointer
1376   //
1377   *TableEntryPointStructure = Smbios30EntryPointStructure;
1378
1379   return EFI_SUCCESS;
1380 }
1381
1382 /**
1383   Create Smbios Table and installs the Smbios Table to the System Table.
1384
1385   @param  Smbios32BitTable    The flag to update 32-bit table.
1386   @param  Smbios64BitTable    The flag to update 64-bit table.
1387
1388 **/
1389 VOID
1390 EFIAPI
1391 SmbiosTableConstruction (
1392   BOOLEAN     Smbios32BitTable,
1393   BOOLEAN     Smbios64BitTable
1394   )
1395 {
1396   UINT8       *Eps;
1397   UINT8       *Eps64Bit;
1398   EFI_STATUS  Status;
1399
1400   if (Smbios32BitTable) {
1401     Status = SmbiosCreateTable ((VOID **) &Eps);
1402     if (!EFI_ERROR (Status)) {
1403       gBS->InstallConfigurationTable (&gEfiSmbiosTableGuid, Eps);
1404     }
1405   }
1406
1407   if (Smbios64BitTable) {
1408     Status = SmbiosCreate64BitTable ((VOID **) &Eps64Bit);
1409     if (!EFI_ERROR (Status)) {
1410       gBS->InstallConfigurationTable (&gEfiSmbios3TableGuid, Eps64Bit);
1411     }
1412   }
1413 }
1414
1415 /**
1416
1417   Driver to produce Smbios protocol and pre-allocate 1 page for the final SMBIOS table.
1418
1419   @param ImageHandle     Module's image handle
1420   @param SystemTable     Pointer of EFI_SYSTEM_TABLE
1421
1422   @retval EFI_SUCCESS    Smbios protocol installed
1423   @retval Other          No protocol installed, unload driver.
1424
1425 **/
1426 EFI_STATUS
1427 EFIAPI
1428 SmbiosDriverEntryPoint (
1429   IN EFI_HANDLE           ImageHandle,
1430   IN EFI_SYSTEM_TABLE     *SystemTable
1431   )
1432 {
1433   EFI_STATUS            Status;
1434
1435   mPrivateData.Signature                = SMBIOS_INSTANCE_SIGNATURE;
1436   mPrivateData.Smbios.Add               = SmbiosAdd;
1437   mPrivateData.Smbios.UpdateString      = SmbiosUpdateString;
1438   mPrivateData.Smbios.Remove            = SmbiosRemove;
1439   mPrivateData.Smbios.GetNext           = SmbiosGetNext;
1440   mPrivateData.Smbios.MajorVersion      = (UINT8) (PcdGet16 (PcdSmbiosVersion) >> 8);
1441   mPrivateData.Smbios.MinorVersion      = (UINT8) (PcdGet16 (PcdSmbiosVersion) & 0x00ff);
1442
1443   InitializeListHead (&mPrivateData.DataListHead);
1444   InitializeListHead (&mPrivateData.AllocatedHandleListHead);
1445   EfiInitializeLock (&mPrivateData.DataLock, TPL_NOTIFY);
1446
1447   //
1448   // Make a new handle and install the protocol
1449   //
1450   mPrivateData.Handle = NULL;
1451   Status = gBS->InstallProtocolInterface (
1452                   &mPrivateData.Handle,
1453                   &gEfiSmbiosProtocolGuid,
1454                   EFI_NATIVE_INTERFACE,
1455                   &mPrivateData.Smbios
1456                   );
1457
1458   return Status;
1459 }