[mirror_edk2.git] / Vlv2TbltDevicePkg / SmBiosMiscDxe / MiscSystemManufacturerFunction.c

/*++

Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
                                                                                   
  This program and the accompanying materials are licensed and made available under
  the terms and conditions of the BSD License that accompanies this distribution.  
  The full text of the license may be found at                                     
  http://opensource.org/licenses/bsd-license.php.                                  
                                                                                   
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,            
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.    
                                                                                   

Module Name:

  MiscSystemManufacturerFunction.c

Abstract:

  This driver parses the mMiscSubclassDataTable structure and reports
  any generated data.

--*/


#include "CommonHeader.h"
#include "MiscSubclassDriver.h"
#include <Protocol/DxeSmmReadyToLock.h>
#include <Library/NetLib.h>
#include "Library/DebugLib.h"
#include <Uefi/UefiBaseType.h>

/**

  Publish the smbios type 1.

  @param Event      Event whose notification function is being invoked (gEfiDxeSmmReadyToLockProtocolGuid).
  @param Context    Pointer to the notification functions context, which is implementation dependent.

  @retval None

**/
EFI_STATUS
EFIAPI
AddSmbiosManuCallback (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{

  CHAR8                             *OptionalStrStart;
  UINTN                             ManuStrLen;
  UINTN                             VerStrLen;
  UINTN                             PdNameStrLen;
  UINTN                             SerialNumStrLen;
  UINTN                             SkuNumberStrLen;
  UINTN				                FamilyNameStrLen;
  EFI_STATUS                        Status;
  EFI_STRING                        Manufacturer;
  EFI_STRING                        ProductName;
  EFI_STRING                        Version;
  EFI_STRING                        SerialNumber;
  EFI_STRING                        SkuNumber;
  EFI_STRING			            FamilyName;
  STRING_REF                        TokenToGet;
  EFI_SMBIOS_HANDLE                 SmbiosHandle;
  SMBIOS_TABLE_TYPE1                *SmbiosRecord;
  EFI_MISC_SYSTEM_MANUFACTURER      *ForType1InputData;
  EFI_SMBIOS_PROTOCOL               *Smbios;
  CHAR16                            Buffer[40];
  
  CHAR16                          *MacStr; 
  EFI_HANDLE                      *Handles;
  UINTN                           BufferSize;

  ForType1InputData = (EFI_MISC_SYSTEM_MANUFACTURER *)Context;

  //
  // First check for invalid parameters.
  //
  if (Context == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID *) &Smbios);
  ASSERT_EFI_ERROR (Status);

  //
  // Silicon Steppings
  //
  switch (PchStepping()) {
    case PchA0:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX A0 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"A0");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "A0 Stepping Detected\n"));
      break;
    case PchA1:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX A1 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"A1");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "A1 Stepping Detected\n"));
      break;
    case PchB0:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B0 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B0");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "B0 Stepping Detected\n"));
      break;
    case PchB1:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B1 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B1");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "B1 Stepping Detected\n"));
      break;
    case PchB2:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B2 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B2");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "B2 Stepping Detected\n"));
      break;
    case PchB3:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B3 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B3");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "B3 Stepping Detected\n"));
      break;
    case PchC0:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX C0 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"C0");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "C0 Stepping Detected\n"));
      break;
   case PchD0:
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX D0 PLATFORM");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
      UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"D0");
      HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
      DEBUG ((EFI_D_ERROR, "D0 Stepping Detected\n"));
      break;
    default:
      DEBUG ((EFI_D_ERROR, "Unknow Stepping Detected\n"));
      break;
    }


  TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_MANUFACTURER);
  Manufacturer = SmbiosMiscGetString (TokenToGet);
  ManuStrLen = StrLen(Manufacturer);
  if (ManuStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }

  TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_PRODUCT_NAME);
  ProductName = SmbiosMiscGetString (TokenToGet);
  PdNameStrLen = StrLen(ProductName);
  if (PdNameStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }

  TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_VERSION);
  Version = SmbiosMiscGetString (TokenToGet);
  VerStrLen = StrLen(Version);
  if (VerStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }

  //
  //Get handle infomation
  //
  BufferSize = 0;
  Handles = NULL;
  Status = gBS->LocateHandle (
                  ByProtocol, 
                  &gEfiSimpleNetworkProtocolGuid,
                  NULL,
                  &BufferSize,
                  Handles
                  );

  if (Status == EFI_BUFFER_TOO_SMALL) {
  	Handles = AllocateZeroPool(BufferSize);
  	if (Handles == NULL) {
  		return (EFI_OUT_OF_RESOURCES);
  	}
  	Status = gBS->LocateHandle(
  	                ByProtocol,
  	                &gEfiSimpleNetworkProtocolGuid,
  	                NULL,
  	                &BufferSize,
  	                Handles
  	                );
 }
 	                
  //
  //Get the MAC string
  //
  Status = NetLibGetMacString (
             *Handles,
             NULL,
             &MacStr
             );
  if (EFI_ERROR (Status)) {	
    return Status;
  }
  SerialNumber = MacStr; 
  SerialNumStrLen = StrLen(SerialNumber);
  if (SerialNumStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }
  TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_SKU_NUMBER);
  SkuNumber = SmbiosMiscGetString (TokenToGet);
  SkuNumberStrLen = StrLen(SkuNumber);
  if (SkuNumberStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }
  TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_FAMILY_NAME1);
  FamilyName = SmbiosMiscGetString (TokenToGet);
  FamilyNameStrLen = StrLen(FamilyName);
  if (FamilyNameStrLen > SMBIOS_STRING_MAX_LENGTH) {
    return EFI_UNSUPPORTED;
  }

  //
  // Two zeros following the last string.
  //
  SmbiosRecord = AllocatePool(sizeof (SMBIOS_TABLE_TYPE1) + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen + 1 + FamilyNameStrLen + 1 + 1);
  ZeroMem(SmbiosRecord, sizeof (SMBIOS_TABLE_TYPE1) + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen + 1 + FamilyNameStrLen + 1 + 1);

  SmbiosRecord->Hdr.Type = EFI_SMBIOS_TYPE_SYSTEM_INFORMATION;
  SmbiosRecord->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE1);

  //
  // Make handle chosen by smbios protocol.add automatically.
  //
  SmbiosRecord->Hdr.Handle = 0;

  //
  // Manu will be the 1st optional string following the formatted structure.
  //
  SmbiosRecord->Manufacturer = 1;

  //
  // ProductName will be the 2nd optional string following the formatted structure.
  //
  SmbiosRecord->ProductName = 2;

  //
  // Version will be the 3rd optional string following the formatted structure.
  //
  SmbiosRecord->Version = 3;

  //
  // Version will be the 4th optional string following the formatted structure.
  //
  SmbiosRecord->SerialNumber = 4;

  SmbiosRecord->SKUNumber= 5;
  SmbiosRecord->Family= 6;

  //
  // Unique UUID
  //
  ForType1InputData->SystemUuid.Data1 = PcdGet32 (PcdProductSerialNumber);
  ForType1InputData->SystemUuid.Data4[0] = PcdGet8 (PcdEmmcManufacturerId);

  CopyMem ((UINT8 *) (&SmbiosRecord->Uuid),&ForType1InputData->SystemUuid,16);

  SmbiosRecord->WakeUpType = (UINT8)ForType1InputData->SystemWakeupType;

  OptionalStrStart = (CHAR8 *)(SmbiosRecord + 1);
  UnicodeStrToAsciiStr(Manufacturer, OptionalStrStart);
  UnicodeStrToAsciiStr(ProductName, OptionalStrStart + ManuStrLen + 1);
  UnicodeStrToAsciiStr(Version, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1);
  UnicodeStrToAsciiStr(SerialNumber, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1);

  UnicodeStrToAsciiStr(SkuNumber, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 +  VerStrLen + 1 + SerialNumStrLen + 1);
  UnicodeStrToAsciiStr(FamilyName, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen +1);

  //
  // Now we have got the full smbios record, call smbios protocol to add this record.
  //
  SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
  Status = Smbios-> Add(
                      Smbios,
                      NULL,
                      &SmbiosHandle,
                      (EFI_SMBIOS_TABLE_HEADER *) SmbiosRecord
                      );
  FreePool(SmbiosRecord);
  return Status;
}

/**
  This function makes boot time changes to the contents of the
  MiscSystemManufacturer (Type 1).

  @param  RecordData                 Pointer to copy of RecordData from the Data Table.

  @retval EFI_SUCCESS                All parameters were valid.
  @retval EFI_UNSUPPORTED            Unexpected RecordType value.
  @retval EFI_INVALID_PARAMETER      Invalid parameter was found.

**/
MISC_SMBIOS_TABLE_FUNCTION(MiscSystemManufacturer)
{
  EFI_STATUS                    Status;
  static BOOLEAN                CallbackIsInstalledManu = FALSE;
  VOID                           *AddSmbiosManuCallbackNotifyReg;
  EFI_EVENT                      AddSmbiosManuCallbackEvent;


  if (CallbackIsInstalledManu == FALSE) {
    CallbackIsInstalledManu = TRUE;        	// Prevent more than 1 callback.
    DEBUG ((EFI_D_INFO, "Create Smbios Manu callback.\n"));

  //
  // gEfiDxeSmmReadyToLockProtocolGuid is ready
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  (EFI_EVENT_NOTIFY)AddSmbiosManuCallback,
                  RecordData,
                  &AddSmbiosManuCallbackEvent
                  );

  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return Status;

  }

  Status = gBS->RegisterProtocolNotify (
                  &gEfiDxeSmmReadyToLockProtocolGuid,
                  AddSmbiosManuCallbackEvent,
                  &AddSmbiosManuCallbackNotifyReg
                  );

  return Status;
  }

  return EFI_SUCCESS;

}
Commit	Line	Data
3cbfba02 DW	1	/*++
	2
	3	Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
	4
	5	This program and the accompanying materials are licensed and made available under
	6	the terms and conditions of the BSD License that accompanies this distribution.
	7	The full text of the license may be found at
	8	http://opensource.org/licenses/bsd-license.php.
	9
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	12
	13
	14
	15	Module Name:
	16
	17	MiscSystemManufacturerFunction.c
	18
	19	Abstract:
	20
	21	This driver parses the mMiscSubclassDataTable structure and reports
	22	any generated data.
	23
	24	--*/
	25
	26
	27	#include "CommonHeader.h"
	28	#include "MiscSubclassDriver.h"
	29	#include <Protocol/DxeSmmReadyToLock.h>
	30	#include <Library/NetLib.h>
	31	#include "Library/DebugLib.h"
	32	#include <Uefi/UefiBaseType.h>
	33
	34	/**
	35
	36	Publish the smbios type 1.
	37
	38	@param Event Event whose notification function is being invoked (gEfiDxeSmmReadyToLockProtocolGuid).
	39	@param Context Pointer to the notification functions context, which is implementation dependent.
	40
	41	@retval None
	42
	43	**/
	44	EFI_STATUS
	45	EFIAPI
	46	AddSmbiosManuCallback (
	47	IN EFI_EVENT Event,
	48	IN VOID *Context
	49	)
	50	{
	51
	52	CHAR8 *OptionalStrStart;
	53	UINTN ManuStrLen;
	54	UINTN VerStrLen;
	55	UINTN PdNameStrLen;
	56	UINTN SerialNumStrLen;
	57	UINTN SkuNumberStrLen;
	58	UINTN FamilyNameStrLen;
	59	EFI_STATUS Status;
	60	EFI_STRING Manufacturer;
	61	EFI_STRING ProductName;
	62	EFI_STRING Version;
	63	EFI_STRING SerialNumber;
	64	EFI_STRING SkuNumber;
65	EFI_STRING FamilyName;
66	STRING_REF TokenToGet;
67	EFI_SMBIOS_HANDLE SmbiosHandle;
68	SMBIOS_TABLE_TYPE1 *SmbiosRecord;
69	EFI_MISC_SYSTEM_MANUFACTURER *ForType1InputData;
70	EFI_SMBIOS_PROTOCOL *Smbios;
71	CHAR16 Buffer[40];
72
73	CHAR16 *MacStr;
74	EFI_HANDLE *Handles;
75	UINTN BufferSize;
76
77	ForType1InputData = (EFI_MISC_SYSTEM_MANUFACTURER *)Context;
78
79	//
80	// First check for invalid parameters.
81	//
82	if (Context == NULL) {
83	return EFI_INVALID_PARAMETER;
84	}
85
86	Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID *) &Smbios);
87	ASSERT_EFI_ERROR (Status);
88
89	//
90	// Silicon Steppings
91	//
92	switch (PchStepping()) {
93	case PchA0:
94	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX A0 PLATFORM");
95	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
96	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"A0");
97	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
98	DEBUG ((EFI_D_ERROR, "A0 Stepping Detected\n"));
99	break;
100	case PchA1:
101	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX A1 PLATFORM");
102	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
103	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"A1");
104	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
105	DEBUG ((EFI_D_ERROR, "A1 Stepping Detected\n"));
106	break;
107	case PchB0:
108	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B0 PLATFORM");
109	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
110	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B0");
111	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
112	DEBUG ((EFI_D_ERROR, "B0 Stepping Detected\n"));
113	break;
114	case PchB1:
115	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B1 PLATFORM");
116	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
117	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B1");
118	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
119	DEBUG ((EFI_D_ERROR, "B1 Stepping Detected\n"));
120	break;
121	case PchB2:
122	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B2 PLATFORM");
123	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
124	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B2");
125	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
126	DEBUG ((EFI_D_ERROR, "B2 Stepping Detected\n"));
127	break;
128	case PchB3:
129	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX B3 PLATFORM");
130	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
131	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"B3");
132	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
133	DEBUG ((EFI_D_ERROR, "B3 Stepping Detected\n"));
134	break;
135	case PchC0:
136	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX C0 PLATFORM");
137	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
138	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"C0");
139	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
140	DEBUG ((EFI_D_ERROR, "C0 Stepping Detected\n"));
141	break;
142	case PchD0:
143	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"MinnowBoard MAX D0 PLATFORM");
144	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_PRODUCT_NAME), Buffer, NULL);
145	UnicodeSPrint (Buffer, sizeof (Buffer),L"%s",L"D0");
146	HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SYSTEM_VERSION), Buffer, NULL);
147	DEBUG ((EFI_D_ERROR, "D0 Stepping Detected\n"));
148	break;
149	default:
150	DEBUG ((EFI_D_ERROR, "Unknow Stepping Detected\n"));
151	break;
152	}
153
154
155	TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_MANUFACTURER);
156	Manufacturer = SmbiosMiscGetString (TokenToGet);
157	ManuStrLen = StrLen(Manufacturer);
158	if (ManuStrLen > SMBIOS_STRING_MAX_LENGTH) {
159	return EFI_UNSUPPORTED;
160	}
161
162	TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_PRODUCT_NAME);
163	ProductName = SmbiosMiscGetString (TokenToGet);
164	PdNameStrLen = StrLen(ProductName);
165	if (PdNameStrLen > SMBIOS_STRING_MAX_LENGTH) {
166	return EFI_UNSUPPORTED;
167	}
168
169	TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_VERSION);
170	Version = SmbiosMiscGetString (TokenToGet);
171	VerStrLen = StrLen(Version);
172	if (VerStrLen > SMBIOS_STRING_MAX_LENGTH) {
173	return EFI_UNSUPPORTED;
174	}
175
176	//
177	//Get handle infomation
178	//
179	BufferSize = 0;
180	Handles = NULL;
181	Status = gBS->LocateHandle (
182	ByProtocol,
183	&gEfiSimpleNetworkProtocolGuid,
184	NULL,
185	&BufferSize,
186	Handles
187	);
188
189	if (Status == EFI_BUFFER_TOO_SMALL) {
190	Handles = AllocateZeroPool(BufferSize);
191	if (Handles == NULL) {
192	return (EFI_OUT_OF_RESOURCES);
193	}
194	Status = gBS->LocateHandle(
195	ByProtocol,
196	&gEfiSimpleNetworkProtocolGuid,
197	NULL,
198	&BufferSize,
199	Handles
200	);
201	}
202
203	//
204	//Get the MAC string
205	//
206	Status = NetLibGetMacString (
207	*Handles,
208	NULL,
209	&MacStr
210	);
211	if (EFI_ERROR (Status)) {
212	return Status;
213	}
214	SerialNumber = MacStr;
215	SerialNumStrLen = StrLen(SerialNumber);
216	if (SerialNumStrLen > SMBIOS_STRING_MAX_LENGTH) {
217	return EFI_UNSUPPORTED;
218	}
219	TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_SKU_NUMBER);
220	SkuNumber = SmbiosMiscGetString (TokenToGet);
221	SkuNumberStrLen = StrLen(SkuNumber);
222	if (SkuNumberStrLen > SMBIOS_STRING_MAX_LENGTH) {
223	return EFI_UNSUPPORTED;
224	}
225	TokenToGet = STRING_TOKEN (STR_MISC_SYSTEM_FAMILY_NAME1);
226	FamilyName = SmbiosMiscGetString (TokenToGet);
227	FamilyNameStrLen = StrLen(FamilyName);
228	if (FamilyNameStrLen > SMBIOS_STRING_MAX_LENGTH) {
229	return EFI_UNSUPPORTED;
230	}
231
232	//
233	// Two zeros following the last string.
234	//
235	SmbiosRecord = AllocatePool(sizeof (SMBIOS_TABLE_TYPE1) + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen + 1 + FamilyNameStrLen + 1 + 1);
236	ZeroMem(SmbiosRecord, sizeof (SMBIOS_TABLE_TYPE1) + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen + 1 + FamilyNameStrLen + 1 + 1);
237
238	SmbiosRecord->Hdr.Type = EFI_SMBIOS_TYPE_SYSTEM_INFORMATION;
239	SmbiosRecord->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE1);
240
241	//
242	// Make handle chosen by smbios protocol.add automatically.
243	//
244	SmbiosRecord->Hdr.Handle = 0;
245
246	//
247	// Manu will be the 1st optional string following the formatted structure.
248	//
249	SmbiosRecord->Manufacturer = 1;
250
251	//
252	// ProductName will be the 2nd optional string following the formatted structure.
253	//
254	SmbiosRecord->ProductName = 2;
255
256	//
257	// Version will be the 3rd optional string following the formatted structure.
258	//
259	SmbiosRecord->Version = 3;
260
261	//
262	// Version will be the 4th optional string following the formatted structure.
263	//
264	SmbiosRecord->SerialNumber = 4;
265
266	SmbiosRecord->SKUNumber= 5;
267	SmbiosRecord->Family= 6;
268
269	//
270	// Unique UUID
271	//
272	ForType1InputData->SystemUuid.Data1 = PcdGet32 (PcdProductSerialNumber);
273	ForType1InputData->SystemUuid.Data4[0] = PcdGet8 (PcdEmmcManufacturerId);
274
275	CopyMem ((UINT8 *) (&SmbiosRecord->Uuid),&ForType1InputData->SystemUuid,16);
276
277	SmbiosRecord->WakeUpType = (UINT8)ForType1InputData->SystemWakeupType;
278
279	OptionalStrStart = (CHAR8 *)(SmbiosRecord + 1);
280	UnicodeStrToAsciiStr(Manufacturer, OptionalStrStart);
281	UnicodeStrToAsciiStr(ProductName, OptionalStrStart + ManuStrLen + 1);
282	UnicodeStrToAsciiStr(Version, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1);
283	UnicodeStrToAsciiStr(SerialNumber, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1);
284
285	UnicodeStrToAsciiStr(SkuNumber, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1);
286	UnicodeStrToAsciiStr(FamilyName, OptionalStrStart + ManuStrLen + 1 + PdNameStrLen + 1 + VerStrLen + 1 + SerialNumStrLen + 1 + SkuNumberStrLen +1);
287
288	//
289	// Now we have got the full smbios record, call smbios protocol to add this record.
290	//
291	SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
292	Status = Smbios-> Add(
293	Smbios,
294	NULL,
295	&SmbiosHandle,
296	(EFI_SMBIOS_TABLE_HEADER *) SmbiosRecord
297	);
298	FreePool(SmbiosRecord);
299	return Status;
300	}
301
302	/**
303	This function makes boot time changes to the contents of the
304	MiscSystemManufacturer (Type 1).
305
306	@param RecordData Pointer to copy of RecordData from the Data Table.
307
308	@retval EFI_SUCCESS All parameters were valid.
309	@retval EFI_UNSUPPORTED Unexpected RecordType value.
310	@retval EFI_INVALID_PARAMETER Invalid parameter was found.
311
312	**/
313	MISC_SMBIOS_TABLE_FUNCTION(MiscSystemManufacturer)
314	{
315	EFI_STATUS Status;
316	static BOOLEAN CallbackIsInstalledManu = FALSE;
317	VOID *AddSmbiosManuCallbackNotifyReg;
318	EFI_EVENT AddSmbiosManuCallbackEvent;
319
320
321	if (CallbackIsInstalledManu == FALSE) {
322	CallbackIsInstalledManu = TRUE; // Prevent more than 1 callback.
323	DEBUG ((EFI_D_INFO, "Create Smbios Manu callback.\n"));
324
325	//
326	// gEfiDxeSmmReadyToLockProtocolGuid is ready
327	//
328	Status = gBS->CreateEvent (
329	EVT_NOTIFY_SIGNAL,
330	TPL_CALLBACK,
331	(EFI_EVENT_NOTIFY)AddSmbiosManuCallback,
332	RecordData,
333	&AddSmbiosManuCallbackEvent
334	);
335
336	ASSERT_EFI_ERROR (Status);
337	if (EFI_ERROR (Status)) {
338	return Status;
339
340	}
341
342	Status = gBS->RegisterProtocolNotify (
343	&gEfiDxeSmmReadyToLockProtocolGuid,
344	AddSmbiosManuCallbackEvent,
345	&AddSmbiosManuCallbackNotifyReg
346	);
347
348	return Status;
349	}
350
351	return EFI_SUCCESS;
352
353	}