/*++
Copyright (c) 1990, 1991 Microsoft Corporation
Module Name:
init386.c
Abstract:
This module is responsible to build any x86 specific entries in
the hardware tree of registry.
Author:
Ken Reneris (kenr) 04-Aug-1992
Environment:
Kernel mode.
Revision History:
shielint - add BIOS date and version detection.
--*/
#include "cmp.h"
#include "stdio.h"
#include "smbios.h"
//
// Title Index is set to 0.
// (from ..\cmconfig.c)
//
#define TITLE_INDEX_VALUE 0
extern PCHAR SearchStrings[];
extern PCHAR BiosBegin;
extern PCHAR Start;
extern PCHAR End;
extern UCHAR CmpID[];
extern WCHAR CmpVendorID[];
extern WCHAR CmpProcessorNameString[];
extern WCHAR CmpFeatureBits[];
extern WCHAR CmpMHz[];
extern WCHAR CmpUpdateSignature[];
extern UCHAR CmpIntelID[];
extern UCHAR CmpItanium[];
extern UCHAR CmpMcKinley[];
extern UCHAR CmpIA64Proc[];
//
// Bios date and version definitions
//
#define BIOS_DATE_LENGTH 64
#define MAXIMUM_BIOS_VERSION_LENGTH 128
WCHAR SystemBIOSDateString[BIOS_DATE_LENGTH];
WCHAR SystemBIOSVersionString[MAXIMUM_BIOS_VERSION_LENGTH];
WCHAR VideoBIOSDateString[BIOS_DATE_LENGTH];
WCHAR VideoBIOSVersionString[MAXIMUM_BIOS_VERSION_LENGTH];
//
// Extended CPUID function definitions
//
#define CPUID_PROCESSOR_NAME_STRING_SZ 65
#define CPUID_EXTFN_BASE 0x80000000
#define CPUID_EXTFN_PROCESSOR_NAME 0x80000002
extern ULONG CmpConfigurationAreaSize;
extern PCM_FULL_RESOURCE_DESCRIPTOR CmpConfigurationData;
BOOLEAN
CmpGetBiosVersion (
PCHAR SearchArea,
ULONG SearchLength,
PCHAR VersionString
);
BOOLEAN
CmpGetBiosDate (
PCHAR SearchArea,
ULONG SearchLength,
PCHAR DateString
);
ULONG
Ke386CyrixId (
VOID
);
VOID
InitializeProcessorInformationFromSMBIOS(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,CmpInitializeMachineDependentConfiguration)
#pragma alloc_text(INIT,InitializeProcessorInformationFromSMBIOS)
#endif
#if 0
//
// Use SMBIOS to gather this information.
//
BOOLEAN
CmpGetBiosDate (
PCHAR SearchArea,
ULONG SearchLength,
PCHAR DateString
)
/*++
Routine Description:
This routine finds the most recent date in the computer/video
card's ROM. When GetRomDate encounters a datae, it checks the
previously found date to see if the new date is more recent.
Arguments:
SearchArea - the area to search for a date.
SearchLength - Length of search.
DateString - Supplies a pointer to a fixed length memory to receive
the date string.
Return Value:
NT_SUCCESS if a date is found.
--*/
{
BOOLEAN FoundFlag = TRUE; // Set to TRUE if the item was found
CHAR PrevDate[BIOS_DATE_LENGTH]; // Date currently being examined
CHAR CurrDate[BIOS_DATE_LENGTH]; // Date currently being examined
PCHAR String;
USHORT i; // Looping variable
USHORT Length; // Number of characters to move
PCHAR Start = SearchArea + 2;
PCHAR End = SearchArea + SearchLength - 5;
//
// Clear out the previous date
//
RtlZeroMemory(PrevDate, BIOS_DATE_LENGTH);
while (FoundFlag) {
String = NULL;
//
// Search for '/' with a digit on either side and another
// '/' 3 character away.
//
while (Start < End) {
if (*Start == '/' && *(Start+3) == '/' &&
(*(Start+1) <= '9' && *(Start+1) >= '0') &&
(*(Start-1) <= '9' && *(Start-1) >= '0') &&
(*(Start+5) <= '9' && *(Start+5) >= '0') &&
(*(Start+4) <= '9' && *(Start+4) >= '0') &&
(*(Start+2) <= '9' && *(Start+2) >= '0')) {
String = Start;
break;
} else {
Start++;
}
}
if (String) {
Start = String + 3;
String -= 2; // Move String to the beginning of
// date.
//
// Copy the year into CurrDate
//
CurrDate[0] = String[6];
CurrDate[1] = String[7];
CurrDate[2] = '/'; // The 1st "/" for YY/MM/DD
//
// Copy the month & day into CurrDate
// (Process properly if this is a one digit month)
//
if (*String > '9' || *String < '0') {
CurrDate[3] = '0';
String++;
i = 4;
Length = 4;
} else {
i = 3;
Length = 5;
}
RtlMoveMemory(&CurrDate[i], String, Length);
//
// Compare the dates, to see which is more recent
//
if (memcmp (PrevDate, CurrDate, BIOS_DATE_LENGTH - 1) < 0) {
RtlMoveMemory(PrevDate, CurrDate, BIOS_DATE_LENGTH - 1);
}
} else {
FoundFlag = FALSE;
}
}
//
// If we did not find a date
//
if (PrevDate[0] == '\0') {
DateString[0] = '\0';
return (FALSE);
}
//
// Put the date from chPrevDate's YY/MM/DD format
// into pchDateString's MM/DD/YY format
DateString[5] = '/';
DateString[6] = PrevDate[0];
DateString[7] = PrevDate[1];
RtlMoveMemory(DateString, &PrevDate[3], 5);
DateString[8] = '\0';
return (TRUE);
}
BOOLEAN
CmpGetBiosVersion (
PCHAR SearchArea,
ULONG SearchLength,
PCHAR VersionString
)
/*++
Routine Description:
This routine finds the version number stored in ROM, if any.
Arguments:
SearchArea - the area to search for the version.
SearchLength - Length of search
VersionString - Supplies a pointer to a fixed length memory to receive
the version string.
Return Value:
TRUE if a version number is found. Else a value of FALSE is returned.
--*/
{
PCHAR String;
USHORT Length;
USHORT i;
CHAR Buffer[MAXIMUM_BIOS_VERSION_LENGTH];
PCHAR BufferPointer;
if (SearchArea != NULL) {
//
// If caller does not specify the search area, we will search
// the area left from previous search.
//
BiosBegin = SearchArea;
Start = SearchArea + 1;
End = SearchArea + SearchLength - 2;
}
while (1) {
//
// Search for a period with a digit on either side
//
String = NULL;
while (Start <= End) {
if (*Start == '.' && *(Start+1) >= '0' && *(Start+1) <= '9' &&
*(Start-1) >= '0' && *(Start-1) <= '9') {
String = Start;
break;
} else {
Start++;
}
}
if (Start > End) {
return(FALSE);
} else {
Start += 2;
}
Length = 0;
Buffer[MAXIMUM_BIOS_VERSION_LENGTH - 1] = '\0';
BufferPointer = &Buffer[MAXIMUM_BIOS_VERSION_LENGTH - 1];
//
// Search for the beginning of the string
//
String--;
while (Length < MAXIMUM_BIOS_VERSION_LENGTH - 8 &&
String >= BiosBegin &&
*String >= ' ' && *String <= 127 &&
*String != '$') {
--BufferPointer;
*BufferPointer = *String;
--String, ++Length;
}
++String;
//
// Can one of the search strings be found
//
for (i = 0; SearchStrings[i]; i++) {
if (strstr(BufferPointer, SearchStrings[i])) {
goto Found;
}
}
}
Found:
//
// Skip leading white space
//
for (; *String == ' '; ++String)
;
//
// Copy the string to user supplied buffer
//
for (i = 0; i < MAXIMUM_BIOS_VERSION_LENGTH - 1 &&
String <= (End + 1) &&
*String >= ' ' && *String <= 127 && *String != '$';
++i, ++String) {
VersionString[i] = *String;
}
VersionString[i] = '\0';
return (TRUE);
}
#endif // #if 0
NTSTATUS
CmpInitializeMachineDependentConfiguration(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This routine creates IA64 specific entries in the registry.
Arguments:
LoaderBlock - supplies a pointer to the LoaderBlock passed in from the
OS Loader.
Returns:
NTSTATUS code for sucess or reason of failure.
--*/
{
NTSTATUS Status;
ULONG VideoBiosStart;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
UNICODE_STRING ValueData;
ANSI_STRING AnsiString;
OBJECT_ATTRIBUTES ObjectAttributes;
ULONG Disposition;
HANDLE ParentHandle;
HANDLE BaseHandle, NpxHandle;
HANDLE CurrentControlSet;
CONFIGURATION_COMPONENT_DATA CurrentEntry;
PUCHAR VendorID;
UCHAR Buffer[MAXIMUM_BIOS_VERSION_LENGTH];
PKPRCB Prcb;
ULONG i, Junk;
ULONG VersionsLength = 0, Length;
PCHAR VersionStrings, VersionPointer;
UNICODE_STRING SectionName;
ULONG ViewSize;
LARGE_INTEGER ViewBase;
PVOID BaseAddress;
USHORT DeviceIndexTable[NUMBER_TYPES];
ULONG CpuIdFunction;
ULONG MaxExtFn;
PULONG NameString = NULL;
ULONG ReturnedLength;
struct {
union {
UCHAR Bytes[CPUID_PROCESSOR_NAME_STRING_SZ];
ULONG DWords[1];
} u;
} ProcessorNameString;
for (i = 0; i < NUMBER_TYPES; i++) {
DeviceIndexTable[i] = 0;
}
//
// Go get a bunch of information out of SMBIOS
//
InitializeProcessorInformationFromSMBIOS(LoaderBlock);
InitializeObjectAttributes( &ObjectAttributes,
&CmRegistryMachineHardwareDescriptionSystemName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey( &ParentHandle,
KEY_READ,
&ObjectAttributes
);
if (!NT_SUCCESS(Status)) {
// Something is really wrong...
return Status;
}
//
// On an ARC machine the processor(s) are included in the hardware
// configuration passed in from bootup. Since there's no standard
// way to get all the ARC information for each processor in an MP
// machine via pc-ROMs the information will be added here (if it's
// not already present).
//
RtlInitUnicodeString( &KeyName,
L"CentralProcessor"
);
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName,
0,
ParentHandle,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
Status = NtCreateKey(
&BaseHandle,
KEY_READ | KEY_WRITE,
&ObjectAttributes,
TITLE_INDEX_VALUE,
&CmClassName[ProcessorClass],
0,
&Disposition
);
NtClose (BaseHandle);
if (Disposition == REG_CREATED_NEW_KEY) {
//
// The ARC rom didn't add the processor(s) into the registry.
// Do it now.
//
CmpConfigurationData = (PCM_FULL_RESOURCE_DESCRIPTOR)ExAllocatePool(
PagedPool,
CmpConfigurationAreaSize
);
if (CmpConfigurationData == NULL) {
// bail out
NtClose (ParentHandle);
return(STATUS_INSUFFICIENT_RESOURCES);
}
for (i=0; i < (ULONG)KeNumberProcessors; i++) {
Prcb = KiProcessorBlock[i];
RtlZeroMemory (&CurrentEntry, sizeof CurrentEntry);
CurrentEntry.ComponentEntry.Class = ProcessorClass;
CurrentEntry.ComponentEntry.Type = CentralProcessor;
CurrentEntry.ComponentEntry.Key = i;
CurrentEntry.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
CurrentEntry.ComponentEntry.Identifier = Buffer;
sprintf( Buffer, CmpID,
Prcb->ProcessorFamily,
Prcb->ProcessorModel,
Prcb->ProcessorRevision
);
CurrentEntry.ComponentEntry.IdentifierLength =
strlen (Buffer) + 1;
Status = CmpInitializeRegistryNode(
&CurrentEntry,
ParentHandle,
&BaseHandle,
-1,
(ULONG)-1,
DeviceIndexTable
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
VendorID = Prcb->ProcessorVendorString;
if ( *VendorID == '\0' ) {
VendorID = NULL;
}
if (VendorID) {
//
// Add Vendor Indentifier to the registry
//
RtlInitUnicodeString(
&ValueName,
CmpVendorID
);
RtlInitAnsiString(
&AnsiString,
VendorID
);
RtlAnsiStringToUnicodeString(
&ValueData,
&AnsiString,
TRUE
);
Status = NtSetValueKey(
BaseHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
ValueData.Buffer,
ValueData.Length + sizeof( UNICODE_NULL )
);
RtlFreeUnicodeString(&ValueData);
}
if ( VendorID && !strcmp( VendorID, CmpIntelID ) ) {
ULONG processorModel;
PUCHAR processorNameString = CmpItanium;
//
// Add Processor Name String to the registry
//
RtlInitUnicodeString(
&ValueName,
CmpProcessorNameString
);
//
// ISSUE-2000/02/10-v-thief - Pseudo cases to be updated when known.
//
processorModel = Prcb->ProcessorModel;
switch( processorModel ) {
case 1: // Pseudo-Itanium:
break;
case 2: // Pseudo-McKinley:
processorNameString = CmpMcKinley;
break;
default:
processorNameString = CmpIA64Proc;
break;
}
RtlInitAnsiString(
&AnsiString,
processorNameString
);
RtlAnsiStringToUnicodeString(
&ValueData,
&AnsiString,
TRUE
);
Status = NtSetValueKey(
BaseHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
ValueData.Buffer,
ValueData.Length + sizeof( UNICODE_NULL )
);
RtlFreeUnicodeString(&ValueData);
}
//
// If more processor IDs have to be restored or initialized,
// check non-IA64 implementations of this function.
//
if ( Prcb->ProcessorFeatureBits ) {
//
// Add processor feature bits to the registry
//
RtlInitUnicodeString(
&ValueName,
CmpFeatureBits
);
Status = NtSetValueKey(
BaseHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_QWORD,
&Prcb->ProcessorFeatureBits,
sizeof( Prcb->ProcessorFeatureBits )
);
}
if (Prcb->MHz) {
//
// Add processor MHz to the registry
//
RtlInitUnicodeString(
&ValueName,
CmpMHz
);
Status = NtSetValueKey(
BaseHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_DWORD,
&Prcb->MHz,
sizeof (Prcb->MHz)
);
}
#if 0
//
// ISSUE-2000/02/01-v-thief
//
if ( Prcb->ProcessorUpdateSignature ) {
//
// Add processor Update Signature to the registry
//
RtlInitUnicodeString(
&ValueName,
CmpUpdateSignature
);
Status = NtSetValueKey(
BaseHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_BINARY,
&Prcb->ProcessorUpdateSignature,
sizeof( Prcb->ProcessorUpdateSignature )
);
}
#endif // 0
//
// Add ia32 floating point enties for iVE.
//
RtlZeroMemory (&CurrentEntry, sizeof CurrentEntry);
CurrentEntry.ComponentEntry.Class = ProcessorClass;
CurrentEntry.ComponentEntry.Type = FloatingPointProcessor;
CurrentEntry.ComponentEntry.Key = i;
CurrentEntry.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
CurrentEntry.ComponentEntry.Identifier = Buffer;
//
// The iVE is defined to look like the Pentium III FP
// This is the value returned by the ia32 CPUID instruction
// on Merced (Itanium)
//
strcpy (Buffer, "x86 Family 7 Model 0 Stepping 0");
CurrentEntry.ComponentEntry.IdentifierLength =
strlen (Buffer) + 1;
Status = CmpInitializeRegistryNode(
&CurrentEntry,
ParentHandle,
&NpxHandle,
-1,
(ULONG)-1,
DeviceIndexTable
);
//
// How odd. Some calls check the status return value
// and others don't. Is this based on required vs. optional
// keys? For the moment, since it was checked on the i386
// then do the check here too...
//
if (!NT_SUCCESS(Status)) {
NtClose(BaseHandle);
return(Status);
}
//
// Only need to close the handle if we succeeded
//
NtClose(NpxHandle);
NtClose(BaseHandle);
}
ExFreePool((PVOID)CmpConfigurationData);
}
//
// Next we try to collect System BIOS date and version strings.
//
if( SystemBIOSDateString[0] != 0 ) {
RtlInitUnicodeString(
&ValueName,
L"SystemBiosDate"
);
Status = NtSetValueKey(
ParentHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
SystemBIOSDateString,
(wcslen(SystemBIOSDateString)+1) * sizeof( WCHAR )
);
}
if( SystemBIOSVersionString[0] != 0 ) {
RtlInitUnicodeString(
&ValueName,
L"SystemBiosVersion"
);
Status = NtSetValueKey(
ParentHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
SystemBIOSVersionString,
(wcslen(SystemBIOSVersionString)+1) * sizeof( WCHAR )
);
}
//
// Next we try to collect Video BIOS date and version strings.
//
if( VideoBIOSDateString[0] != 0 ) {
RtlInitUnicodeString(
&ValueName,
L"VideoBiosDate"
);
Status = NtSetValueKey(
ParentHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
VideoBIOSDateString,
(wcslen(VideoBIOSDateString)+1) * sizeof( WCHAR )
);
}
if( VideoBIOSVersionString[0] != 0 ) {
RtlInitUnicodeString(
&ValueName,
L"VideoBiosVersion"
);
Status = NtSetValueKey(
ParentHandle,
&ValueName,
TITLE_INDEX_VALUE,
REG_SZ,
VideoBIOSVersionString,
(wcslen(VideoBIOSVersionString)+1) * sizeof( WCHAR )
);
}
NtClose (ParentHandle);
//
// Add any other x86 specific code here...
//
return STATUS_SUCCESS;
}
VOID
InitializeProcessorInformationFromSMBIOS(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This function attempts to load processor-specific information
out of the SMBIOS table. If present, that information will be
used to initialize specific global variables.
Arguments:
LoaderBlock : Pointer to the loaderblock as sent in from the loader.
Return Value:
NONE.
--*/
{
PLOADER_PARAMETER_EXTENSION LoaderExtension;
NTSTATUS Status = STATUS_SUCCESS;
PSMBIOS_EPS_HEADER SMBiosEPSHeader;
PDMIBIOS_EPS_HEADER DMIBiosEPSHeader;
BOOLEAN Found = FALSE;
PHYSICAL_ADDRESS SMBiosTablePhysicalAddress = {0};
PUCHAR StartPtr = NULL;
PUCHAR EndPtr = NULL;
PUCHAR SMBiosDataVirtualAddress = NULL;
PSMBIOS_STRUCT_HEADER Header = NULL;
ULONG i = 0;
PKPRCB Prcb;
UCHAR Checksum;
PAGED_CODE();
LoaderExtension = LoaderBlock->Extension;
if (LoaderExtension->Size >= sizeof(LOADER_PARAMETER_EXTENSION)) {
if (LoaderExtension->SMBiosEPSHeader != NULL) {
//
// Load the SMBIOS table address and checksum it just to make sure.
//
SMBiosEPSHeader = (PSMBIOS_EPS_HEADER)LoaderExtension->SMBiosEPSHeader;
DMIBiosEPSHeader = (PDMIBIOS_EPS_HEADER)&SMBiosEPSHeader->Signature2[0];
SMBiosTablePhysicalAddress.HighPart = 0;
SMBiosTablePhysicalAddress.LowPart = DMIBiosEPSHeader->StructureTableAddress;
StartPtr = (PUCHAR)SMBiosEPSHeader;
Checksum = 0;
for( i = 0; i < SMBiosEPSHeader->Length; i++ ) {
Checksum += StartPtr[i];
}
if( Checksum != 0 ) {
CmKdPrintEx((DPFLTR_CONFIG_ID,DPFLTR_TRACE_LEVEL,"InitializeProcessorInformationFromSMBIOS: _SM_ table has an incorrect checksum.\n"));
return;
}
//
// Map the table into a virtual address and search it.
//
SMBiosDataVirtualAddress = MmMapIoSpace( SMBiosTablePhysicalAddress,
DMIBiosEPSHeader->StructureTableLength,
MmCached );
if( SMBiosDataVirtualAddress != NULL ) {
//
// Search...
//
StartPtr = SMBiosDataVirtualAddress;
EndPtr = StartPtr + DMIBiosEPSHeader->StructureTableLength;
Found = FALSE;
while( (StartPtr < EndPtr) ) {
Header = (PSMBIOS_STRUCT_HEADER)StartPtr;
if( Header->Type == SMBIOS_BIOS_INFORMATION_TYPE ) {
PSMBIOS_BIOS_INFORMATION_STRUCT InfoHeader = (PSMBIOS_BIOS_INFORMATION_STRUCT)StartPtr;
PUCHAR StringPtr = NULL;
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: SMBIOS_BIOS_INFORMATION\n"));
//
// Load the System BIOS Version information.
//
// Now jump to the BiosInfoHeader->BIOSVersion-th string which
// is appended onto the end of the formatted section of the table.
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the version string is at offset: %d\n", (ULONG)InfoHeader->Version));
if( (ULONG)InfoHeader->Version > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Version-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
// StringPtr should be sitting at the BIOSVersion string. Convert him to
// Unicode and save it off.
if( StringPtr < EndPtr ) {
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I'm about to load the Version string %s\n", StringPtr));
UnicodeString.Buffer = SystemBIOSVersionString;
UnicodeString.MaximumLength = MAXIMUM_BIOS_VERSION_LENGTH;
RtlInitAnsiString(
&AnsiString,
StringPtr
);
RtlAnsiStringToUnicodeString(
&UnicodeString,
&AnsiString,
FALSE
);
}
}
//
// Load the System BIOS Date information
//
// Now jump to the BiosInfoHeader->BIOSDate-th string which
// is appended onto the end of the formatted section of the table.
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the ReleaseDate string is at offset: %d\n", (ULONG)InfoHeader->ReleaseDate));
if( (ULONG)InfoHeader->ReleaseDate > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->ReleaseDate-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
// StringPtr should be sitting at the BIOSDate string. Convert him to
// Unicode and save it off.
if( StringPtr < EndPtr ) {
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I'm about to load the Date string %s\n", StringPtr));
UnicodeString.Buffer = SystemBIOSDateString;
UnicodeString.MaximumLength = BIOS_DATE_LENGTH;
RtlInitAnsiString(
&AnsiString,
StringPtr
);
RtlAnsiStringToUnicodeString(
&UnicodeString,
&AnsiString,
FALSE
);
}
}
} else if( Header->Type == SMBIOS_BASE_BOARD_INFORMATION_TYPE ) {
PSMBIOS_BASE_BOARD_INFORMATION_STRUCT InfoHeader = (PSMBIOS_BASE_BOARD_INFORMATION_STRUCT)StartPtr;
PUCHAR StringPtr = NULL;
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: SMBIOS_BASE_BOARD_INFORMATION\n"));
#if 0
//
// We aren't using any of this information right now.
// -matth 4/2001
//
// Manufacturer
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Manufacturer string is at offset: %d\n", (ULONG)InfoHeader->Manufacturer));
if( (ULONG)InfoHeader->Manufacturer > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Manufacturer-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," Manufacturer: %s\n", StringPtr));
}
// Product
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Product string is at offset: %d\n", (ULONG)InfoHeader->Product));
if( (ULONG)InfoHeader->Product > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Product-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," Product: %s\n", StringPtr));
}
// Version
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Version string is at offset: %d\n", (ULONG)InfoHeader->Version));
if( (ULONG)InfoHeader->Version > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Version-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," Version: %s\n", StringPtr));
}
// SerialNumber
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the SerialNumber string is at offset: %d\n", (ULONG)InfoHeader->SerialNumber));
if( (ULONG)InfoHeader->SerialNumber > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->SerialNumber-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," SerialNumber: %s\n", StringPtr));
}
#endif
} else if( Header->Type == SMBIOS_SYSTEM_CHASIS_INFORMATION_TYPE ) {
PSMBIOS_SYSTEM_CHASIS_INFORMATION_STRUCT InfoHeader = (PSMBIOS_SYSTEM_CHASIS_INFORMATION_STRUCT)StartPtr;
PUCHAR StringPtr = NULL;
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: SMBIOS_SYSTEM_CHASIS_INFORMATION\n"));
#if 0
//
// We aren't using any of this information right now.
// -matth 4/2001
//
// Manufacturer
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Manufacturer string is at offset: %d\n", (ULONG)InfoHeader->Manufacturer));
if( (ULONG)InfoHeader->Manufacturer > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Manufacturer-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," Manufacturer: %s\n", StringPtr));
}
// Product
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Manufacturer string is at offset: %d\n", (ULONG)InfoHeader->ChasisType));
if( (ULONG)InfoHeader->ChasisType > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->ChasisType-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," ChasisType: %s\n", StringPtr));
}
// Version
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the Version string is at offset: %d\n", (ULONG)InfoHeader->Version));
if( (ULONG)InfoHeader->Version > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->Version-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," Version: %s\n", StringPtr));
}
// SerialNumber
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," I think the SerialNumber string is at offset: %d\n", (ULONG)InfoHeader->SerialNumber));
if( (ULONG)InfoHeader->SerialNumber > 0 ) {
// Jump to the end of the formatted portion of the SMBIOS table.
StringPtr = StartPtr + Header->Length;
// Jump over some number of strings to get to our string.
for( i = 0; i < ((ULONG)InfoHeader->SerialNumber-1); i++ ) {
while( (*StringPtr != 0) && (StringPtr < EndPtr) ) {
StringPtr++;
}
StringPtr++;
}
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL," SerialNumber: %s\n", StringPtr));
}
#endif
}
//
// Go to the next table.
//
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: Haven't found the ProcessorInformation block yet. Just looked at a block of type: %d.\n", Header->Type));
StartPtr += Header->Length;
// jump over any trailing string-list too.
while ( (*((USHORT UNALIGNED *)StartPtr) != 0) &&
(StartPtr < EndPtr) )
{
StartPtr++;
}
StartPtr += 2;
}
MmUnmapIoSpace(SMBiosDataVirtualAddress, DMIBiosEPSHeader->StructureTableLength);
} else {
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: Failed to map the SMBIOS physical address.\n"));
}
} else {
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: The SMBiosEPSHeader is NULL in the extension block.\n"));
}
} else {
KdPrintEx((DPFLTR_SYSTEM_ID, DPFLTR_INFO_LEVEL,"InitializeProcessorInformationFromSMBIOS: LoaderBlock extension is out of sync with the kernel.\n"));
}
}