1637 lines
42 KiB
C
1637 lines
42 KiB
C
//depot/Lab01_N/base/ntos/config/i386/init386.c#4 - edit change 6794 (text)
|
||
/*++
|
||
|
||
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 "acpitabl.h"
|
||
#include "ntacpi.h"
|
||
#include "rules.h"
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
#include "string.h"
|
||
#include "stdlib.h"
|
||
#include "ntverp.h"
|
||
#endif
|
||
|
||
|
||
typedef struct _ACPI_BIOS_INFORMATION {
|
||
ULONG BootArchitecture;
|
||
ULONG PreferredProfile;
|
||
ULONG Capabilities;
|
||
} ACPI_BIOS_INFORMATION, *PACPI_BIOS_INFORMATION;
|
||
//
|
||
// Title Index is set to 0.
|
||
// (from ..\cmconfig.c)
|
||
//
|
||
|
||
#define TITLE_INDEX_VALUE 0
|
||
|
||
extern const PCHAR SearchStrings[];
|
||
extern PCHAR BiosBegin;
|
||
extern PCHAR Start;
|
||
extern PCHAR End;
|
||
extern const UCHAR CmpID1[];
|
||
extern const UCHAR CmpID2[];
|
||
extern const WCHAR CmpVendorID[];
|
||
extern const WCHAR CmpProcessorNameString[];
|
||
extern const WCHAR CmpFeatureBits[];
|
||
extern const WCHAR CmpMHz[];
|
||
extern const WCHAR CmpUpdateSignature[];
|
||
extern const WCHAR CmPhysicalAddressExtension[];
|
||
|
||
#if !defined(_AMD64_)
|
||
extern const UCHAR CmpCyrixID[];
|
||
#endif
|
||
|
||
extern const UCHAR CmpIntelID[];
|
||
extern const UCHAR CmpAmdID[];
|
||
|
||
//
|
||
// Bios date and version definitions
|
||
//
|
||
|
||
#define BIOS_DATE_LENGTH 11
|
||
#define MAXIMUM_BIOS_VERSION_LENGTH 128
|
||
#define SYSTEM_BIOS_START 0xF0000
|
||
#define SYSTEM_BIOS_LENGTH 0x10000
|
||
#define INT10_VECTOR 0x10
|
||
#define VIDEO_BIOS_START 0xC0000
|
||
#define VIDEO_BIOS_LENGTH 0x8000
|
||
#define VERSION_DATA_LENGTH PAGE_SIZE
|
||
|
||
//
|
||
// Extended CPUID function definitions
|
||
//
|
||
|
||
#define CPUID_PROCESSOR_NAME_STRING_SZ 49
|
||
#define CPUID_EXTFN_BASE 0x80000000
|
||
#define CPUID_EXTFN_PROCESSOR_NAME 0x80000002
|
||
|
||
//
|
||
// CPU Stepping mismatch.
|
||
//
|
||
|
||
UCHAR CmProcessorMismatch;
|
||
|
||
#define CM_PROCESSOR_MISMATCH_VENDOR 0x01
|
||
#define CM_PROCESSOR_MISMATCH_STEPPING 0x02
|
||
#define CM_PROCESSOR_MISMATCH_L2 0x04
|
||
|
||
|
||
extern ULONG CmpConfigurationAreaSize;
|
||
extern PCM_FULL_RESOURCE_DESCRIPTOR CmpConfigurationData;
|
||
|
||
|
||
BOOLEAN
|
||
CmpGetBiosVersion (
|
||
PCHAR SearchArea,
|
||
ULONG SearchLength,
|
||
PCHAR VersionString
|
||
);
|
||
|
||
BOOLEAN
|
||
CmpGetAcpiBiosVersion(
|
||
PCHAR VersionString
|
||
);
|
||
|
||
BOOLEAN
|
||
CmpGetBiosDate (
|
||
PCHAR SearchArea,
|
||
ULONG SearchLength,
|
||
PCHAR DateString,
|
||
BOOLEAN SystemBiosDate
|
||
);
|
||
|
||
BOOLEAN
|
||
CmpGetAcpiBiosInformation(
|
||
PACPI_BIOS_INFORMATION AcpiBiosInformation
|
||
);
|
||
|
||
ULONG
|
||
Ke386CyrixId (
|
||
VOID
|
||
);
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
|
||
VOID
|
||
CmpPerformMachineIdentification(
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
);
|
||
|
||
#endif
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(INIT,CmpGetBiosDate)
|
||
#pragma alloc_text(INIT,CmpGetBiosVersion)
|
||
#pragma alloc_text(INIT,CmpGetAcpiBiosVersion)
|
||
#pragma alloc_text(INIT,CmpGetAcpiBiosInformation)
|
||
#pragma alloc_text(INIT,CmpInitializeMachineDependentConfiguration)
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
#pragma alloc_text(INIT,CmpPerformMachineIdentification)
|
||
#endif
|
||
|
||
#endif
|
||
|
||
#if defined(_AMD64_)
|
||
|
||
#define KeI386NpxPresent TRUE
|
||
|
||
VOID
|
||
__inline
|
||
CPUID (
|
||
ULONG InEax,
|
||
PULONG OutEax,
|
||
PULONG OutEbx,
|
||
PULONG OutEcx,
|
||
PULONG OutEdx
|
||
)
|
||
{
|
||
CPU_INFO cpuInfo;
|
||
|
||
KiCpuId (InEax, &cpuInfo);
|
||
|
||
*OutEax = cpuInfo.Eax;
|
||
*OutEbx = cpuInfo.Ebx;
|
||
*OutEcx = cpuInfo.Ecx;
|
||
*OutEdx = cpuInfo.Edx;
|
||
}
|
||
|
||
#endif
|
||
|
||
|
||
BOOLEAN
|
||
CmpGetBiosDate (
|
||
PCHAR SearchArea,
|
||
ULONG SearchLength,
|
||
PCHAR DateString,
|
||
BOOLEAN SystemBiosDate
|
||
)
|
||
|
||
/*++
|
||
|
||
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.
|
||
|
||
--*/
|
||
|
||
{
|
||
CHAR prevDate[BIOS_DATE_LENGTH]; // Newest date found so far (CCYY/MM/DD)
|
||
CHAR currDate[BIOS_DATE_LENGTH]; // Date currently being examined (CCYY/MM/DD)
|
||
PCHAR start; // Start of the current search area.
|
||
PCHAR end; // End of the search area.
|
||
ULONG year; // YY
|
||
ULONG month; // MM
|
||
ULONG day; // DD
|
||
ULONG count;
|
||
|
||
#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
|
||
|
||
//
|
||
// Initialize previous date
|
||
//
|
||
|
||
RtlZeroMemory(prevDate, BIOS_DATE_LENGTH);
|
||
|
||
//
|
||
// We need to look ahead 5 characters to determine the
|
||
// validity of the date pattern.
|
||
//
|
||
|
||
start = SearchArea + 2;
|
||
end = SearchArea + SearchLength - 5;
|
||
|
||
//
|
||
// Process the entire search area.
|
||
//
|
||
|
||
while (start < end) {
|
||
|
||
//
|
||
// We consider the following byte pattern as a potential date.
|
||
// We are assuming the following date pattern Month/Day/Year.
|
||
// "n/nn/nn" where n is any digit. We allow month to be single
|
||
// digit only.
|
||
//
|
||
|
||
if ( start[0] == '/' && start[3] == '/' &&
|
||
IS_DIGIT(*(start - 1)) &&
|
||
IS_DIGIT(start[1]) && IS_DIGIT(start[2]) &&
|
||
IS_DIGIT(start[4]) && IS_DIGIT(start[5])) {
|
||
|
||
//
|
||
// Copy MM/DD part into the currDate.
|
||
//
|
||
|
||
RtlMoveMemory(&currDate[5], start - 2, 5);
|
||
|
||
//
|
||
// Handle single digit month correctly.
|
||
//
|
||
|
||
if (!IS_DIGIT(currDate[5])) {
|
||
currDate[5] = '0';
|
||
}
|
||
|
||
//
|
||
// Copy the year YY into currDate
|
||
//
|
||
|
||
currDate[2] = start[4];
|
||
currDate[3] = start[5];
|
||
currDate[4] = currDate[7] = currDate[10] = '\0';
|
||
|
||
//
|
||
// Do basic validation for the date.
|
||
// Only one field (YY) can be 0.
|
||
// Only one field (YY) can be greater than 31.
|
||
// We assume the ROM date to be in the format MM/DD/YY.
|
||
//
|
||
|
||
year = strtoul(&currDate[2], NULL, 16);
|
||
month = strtoul(&currDate[5], NULL, 16);
|
||
day = strtoul(&currDate[8], NULL, 16);
|
||
|
||
//
|
||
// Count the number of fields that are 0.
|
||
//
|
||
|
||
count = ((day == 0)? 1 : 0) + ((month == 0)? 1 : 0) + ((year == 0)? 1 : 0);
|
||
if (count <= 1) {
|
||
|
||
//
|
||
// Count number of field that are greater than 31.
|
||
//
|
||
|
||
count = ((day > 0x31)? 1 : 0) + ((month > 0x31)? 1 : 0) + ((year > 0x31)? 1 : 0);
|
||
if (count <= 1) {
|
||
|
||
//
|
||
// See if the ROM already has a 4 digit date. We do this only for System ROM
|
||
// since they have a consistent date format.
|
||
//
|
||
|
||
if (SystemBiosDate && IS_DIGIT(start[6]) && IS_DIGIT(start[7]) &&
|
||
(memcmp(&start[4], "19", 2) == 0 || memcmp(&start[4], "20", 2) == 0)) {
|
||
|
||
currDate[0] = start[4];
|
||
currDate[1] = start[5];
|
||
currDate[2] = start[6];
|
||
currDate[3] = start[7];
|
||
|
||
} else {
|
||
|
||
//
|
||
// Internally, we treat year as a 4 digit quantity
|
||
// for comparison to determine the newest date.
|
||
// We treat year YY < 80 as 20YY, otherwise 19YY.
|
||
//
|
||
|
||
if (year < 0x80) {
|
||
currDate[0] = '2';
|
||
currDate[1] = '0';
|
||
} else {
|
||
currDate[0] = '1';
|
||
currDate[1] = '9';
|
||
}
|
||
}
|
||
|
||
//
|
||
// Add the '/' delimiters into the date.
|
||
//
|
||
|
||
currDate[4] = currDate[7] = '/';
|
||
|
||
//
|
||
// Compare the dates, and save the newer one.
|
||
//
|
||
|
||
if (memcmp (prevDate, currDate, BIOS_DATE_LENGTH - 1) < 0) {
|
||
RtlMoveMemory(prevDate, currDate, BIOS_DATE_LENGTH - 1);
|
||
}
|
||
|
||
//
|
||
// Next search should start at the second '/'.
|
||
//
|
||
|
||
start += 2;
|
||
}
|
||
}
|
||
}
|
||
start++;
|
||
}
|
||
|
||
if (prevDate[0] != '\0') {
|
||
|
||
//
|
||
// Convert from the internal CCYY/MM/DD format to
|
||
// return MM/DD//YY format.
|
||
//
|
||
|
||
RtlMoveMemory(DateString, &prevDate[5], 5);
|
||
DateString[5] = '/';
|
||
DateString[6] = prevDate[2];
|
||
DateString[7] = prevDate[3];
|
||
DateString[8] = '\0';
|
||
|
||
return (TRUE);
|
||
}
|
||
|
||
//
|
||
// If we did not find a date, return an empty string.
|
||
//
|
||
|
||
DateString[0] = '\0';
|
||
return (FALSE);
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
BOOLEAN
|
||
CmpGetAcpiBiosVersion(
|
||
PCHAR VersionString
|
||
)
|
||
{
|
||
ULONG length;
|
||
PDESCRIPTION_HEADER header;
|
||
ULONG i;
|
||
|
||
header = CmpFindACPITable(RSDT_SIGNATURE, &length);
|
||
if (header) {
|
||
|
||
for (i = 0; i < 6 && header->OEMID[i]; i++) {
|
||
|
||
*VersionString++ = header->OEMID[i];
|
||
}
|
||
sprintf(VersionString, " - %x", header->OEMRevision);
|
||
|
||
//
|
||
// Unmap the table
|
||
//
|
||
MmUnmapIoSpace(header, length );
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
BOOLEAN
|
||
CmpGetAcpiBiosInformation(
|
||
PACPI_BIOS_INFORMATION AcpiBiosInformation
|
||
)
|
||
{
|
||
ULONG length;
|
||
PFADT fadt;
|
||
BOOLEAN result;
|
||
|
||
AcpiBiosInformation->BootArchitecture = 0;
|
||
AcpiBiosInformation->Capabilities = 0;
|
||
AcpiBiosInformation->PreferredProfile = 0;
|
||
fadt = (PFADT)CmpFindACPITable(FADT_SIGNATURE, &length);
|
||
if (fadt) {
|
||
|
||
//
|
||
// Information is valid only for ACPI version > 1.0
|
||
//
|
||
|
||
if (fadt->Header.Revision > 1) {
|
||
|
||
AcpiBiosInformation->BootArchitecture = fadt->boot_arch;
|
||
AcpiBiosInformation->Capabilities = fadt->flags;
|
||
AcpiBiosInformation->PreferredProfile = fadt->pm_profile;
|
||
}
|
||
|
||
result = (fadt->Header.Revision > 1)? TRUE : FALSE;
|
||
|
||
//
|
||
// Unmap the table
|
||
//
|
||
|
||
MmUnmapIoSpace(fadt, length);
|
||
|
||
return result;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
NTSTATUS
|
||
CmpInitializeMachineDependentConfiguration(
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine creates x86 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;
|
||
UCHAR const* VendorID;
|
||
UCHAR Buffer[MAXIMUM_BIOS_VERSION_LENGTH];
|
||
PKPRCB Prcb;
|
||
ULONG i, Junk;
|
||
ULONG VersionsLength = 0, Length;
|
||
PCHAR VersionStrings, VersionPointer;
|
||
UNICODE_STRING SectionName;
|
||
SIZE_T ViewSize;
|
||
LARGE_INTEGER ViewBase;
|
||
PVOID BaseAddress;
|
||
HANDLE SectionHandle;
|
||
USHORT DeviceIndexTable[NUMBER_TYPES];
|
||
ULONG CpuIdFunction;
|
||
ULONG MaxExtFn;
|
||
PULONG NameString = NULL;
|
||
ULONG P0L2Size = 0;
|
||
ULONG ThisProcessorL2Size;
|
||
struct {
|
||
union {
|
||
UCHAR Bytes[CPUID_PROCESSOR_NAME_STRING_SZ];
|
||
ULONG DWords[1];
|
||
} u;
|
||
} ProcessorNameString;
|
||
ULONG VersionPass;
|
||
ACPI_BIOS_INFORMATION AcpiBiosInformation;
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
HANDLE BiosInfo;
|
||
#endif
|
||
|
||
|
||
for (i = 0; i < NUMBER_TYPES; i++) {
|
||
DeviceIndexTable[i] = 0;
|
||
}
|
||
|
||
InitializeObjectAttributes( &ObjectAttributes,
|
||
&CmRegistryMachineSystemCurrentControlSetControlSessionManagerMemoryManagement,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
Status = NtOpenKey( &BaseHandle,
|
||
KEY_READ | KEY_WRITE,
|
||
&ObjectAttributes
|
||
);
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
|
||
ULONG paeEnabled;
|
||
|
||
if (SharedUserData->ProcessorFeatures[PF_PAE_ENABLED] == FALSE) {
|
||
paeEnabled = 0;
|
||
} else {
|
||
paeEnabled = 1;
|
||
}
|
||
|
||
RtlInitUnicodeString( &ValueName,
|
||
CmPhysicalAddressExtension );
|
||
|
||
|
||
NtSetValueKey( BaseHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&paeEnabled,
|
||
sizeof(paeEnabled) );
|
||
|
||
NtClose( BaseHandle );
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
InitializeObjectAttributes( &ObjectAttributes,
|
||
&CmRegistryMachineHardwareDescriptionSystemName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
Status = NtCreateKey( &ParentHandle,
|
||
KEY_READ,
|
||
&ObjectAttributes,
|
||
0,
|
||
NULL,
|
||
0,
|
||
NULL);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
// Something is really wrong...
|
||
return Status;
|
||
}
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
|
||
InitializeObjectAttributes( &ObjectAttributes,
|
||
&CmRegistryMachineSystemCurrentControlSetControlBiosInfo,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
Status = NtCreateKey( &BiosInfo,
|
||
KEY_ALL_ACCESS,
|
||
&ObjectAttributes,
|
||
0,
|
||
NULL,
|
||
REG_OPTION_NON_VOLATILE,
|
||
&Disposition
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
// Something is really wrong...
|
||
return Status;
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// 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,
|
||
0,
|
||
NULL,
|
||
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 == 0) {
|
||
// <do something useful>
|
||
// Note: we don't actually use it so it doesn't matter for now
|
||
// since it isn't used until the free. go figure.
|
||
// }
|
||
//
|
||
|
||
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;
|
||
if (Prcb->CpuID == 0) {
|
||
|
||
//
|
||
// Old style stepping format
|
||
//
|
||
|
||
sprintf (Buffer, CmpID1,
|
||
Prcb->CpuType,
|
||
(Prcb->CpuStep >> 8) + 'A',
|
||
Prcb->CpuStep & 0xff
|
||
);
|
||
|
||
} else {
|
||
|
||
//
|
||
// New style stepping format
|
||
//
|
||
|
||
sprintf (Buffer, CmpID2,
|
||
Prcb->CpuType,
|
||
(Prcb->CpuStep >> 8),
|
||
Prcb->CpuStep & 0xff
|
||
);
|
||
}
|
||
|
||
CurrentEntry.ComponentEntry.IdentifierLength =
|
||
strlen (Buffer) + 1;
|
||
|
||
Status = CmpInitializeRegistryNode(
|
||
&CurrentEntry,
|
||
ParentHandle,
|
||
&BaseHandle,
|
||
-1,
|
||
(ULONG)-1,
|
||
DeviceIndexTable
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
return(Status);
|
||
}
|
||
|
||
|
||
if (KeI386NpxPresent) {
|
||
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;
|
||
|
||
if (Prcb->CpuType == 3) {
|
||
|
||
//
|
||
// 386 processors have 387's installed, else
|
||
// use processor identifier as the NPX identifier
|
||
//
|
||
|
||
strcpy (Buffer, "80387");
|
||
}
|
||
|
||
CurrentEntry.ComponentEntry.IdentifierLength =
|
||
strlen (Buffer) + 1;
|
||
|
||
Status = CmpInitializeRegistryNode(
|
||
&CurrentEntry,
|
||
ParentHandle,
|
||
&NpxHandle,
|
||
-1,
|
||
(ULONG)-1,
|
||
DeviceIndexTable
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
NtClose(BaseHandle);
|
||
return(Status);
|
||
}
|
||
|
||
NtClose(NpxHandle);
|
||
}
|
||
|
||
//
|
||
// If processor supports Cpu Indentification then
|
||
// go obtain that information for the registry
|
||
//
|
||
|
||
VendorID = Prcb->CpuID ? Prcb->VendorString : NULL;
|
||
|
||
//
|
||
// Move to target processor and get other related
|
||
// processor information for the registery
|
||
//
|
||
|
||
KeSetSystemAffinityThread(Prcb->SetMember);
|
||
|
||
#if !defined(_AMD64_)
|
||
if (!Prcb->CpuID) {
|
||
|
||
//
|
||
// Test for Cyrix processor
|
||
//
|
||
|
||
if (Ke386CyrixId ()) {
|
||
VendorID = CmpCyrixID;
|
||
}
|
||
} else
|
||
#endif
|
||
{
|
||
|
||
//
|
||
// If this processor has extended CPUID functions, get
|
||
// the ProcessorNameString. Although the Intel books
|
||
// say that for CpuID functions > than the valued
|
||
// returned for function 0 will return undefined results,
|
||
// we have a guarantee from Intel that that result will
|
||
// never have the highest order bit set. This enables
|
||
// us to determine if the extended functions are supported
|
||
// by issuing CpuID function 0x80000000.
|
||
//
|
||
// Note: It is not known that this is true for all x86
|
||
// clones. If/when we find exceptions we will support
|
||
// them. In the mean time we are asking the clone makers
|
||
// to guarantee this behavior.
|
||
//
|
||
|
||
CPUID(CPUID_EXTFN_BASE, &MaxExtFn, &Junk, &Junk, &Junk);
|
||
|
||
if (MaxExtFn >= (CPUID_EXTFN_PROCESSOR_NAME + 2)) {
|
||
|
||
//
|
||
// This processor supports extended CPUID functions
|
||
// up to and (at least) including processor name string.
|
||
//
|
||
// Each CPUID call for the processor name string will
|
||
// return 16 bytes, 48 bytes in all, zero terminated.
|
||
//
|
||
|
||
NameString = &ProcessorNameString.u.DWords[0];
|
||
|
||
for (CpuIdFunction = CPUID_EXTFN_PROCESSOR_NAME;
|
||
CpuIdFunction <= (CPUID_EXTFN_PROCESSOR_NAME+2);
|
||
CpuIdFunction++) {
|
||
|
||
CPUID(CpuIdFunction,
|
||
NameString,
|
||
NameString + 1,
|
||
NameString + 2,
|
||
NameString + 3);
|
||
NameString += 4;
|
||
}
|
||
|
||
//
|
||
// Enforce 0 byte terminator.
|
||
//
|
||
|
||
ProcessorNameString.u.Bytes[CPUID_PROCESSOR_NAME_STRING_SZ-1] = 0;
|
||
}
|
||
}
|
||
|
||
ThisProcessorL2Size = KeGetPcr()->SecondLevelCacheSize;
|
||
|
||
//
|
||
// Restore thread's affinity to all processors
|
||
//
|
||
|
||
KeRevertToUserAffinityThread();
|
||
|
||
if (NameString) {
|
||
|
||
//
|
||
// Add Processor Name String to the registery
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
CmpProcessorNameString
|
||
);
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
ProcessorNameString.u.Bytes
|
||
);
|
||
|
||
RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
BaseHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_SZ,
|
||
ValueData.Buffer,
|
||
ValueData.Length + sizeof( UNICODE_NULL )
|
||
);
|
||
|
||
RtlFreeUnicodeString(&ValueData);
|
||
}
|
||
|
||
if (VendorID) {
|
||
|
||
//
|
||
// Add Vendor Indentifier to the registery
|
||
//
|
||
|
||
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 (Prcb->FeatureBits) {
|
||
//
|
||
// Add processor feature bits to the registery
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
CmpFeatureBits
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
BaseHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&Prcb->FeatureBits,
|
||
sizeof (Prcb->FeatureBits)
|
||
);
|
||
}
|
||
|
||
if (Prcb->MHz) {
|
||
//
|
||
// Add processor MHz to the registery
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
CmpMHz
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
BaseHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&Prcb->MHz,
|
||
sizeof (Prcb->MHz)
|
||
);
|
||
}
|
||
|
||
if (Prcb->UpdateSignature.QuadPart) {
|
||
//
|
||
// Add processor MHz to the registery
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
CmpUpdateSignature
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
BaseHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_BINARY,
|
||
&Prcb->UpdateSignature,
|
||
sizeof (Prcb->UpdateSignature)
|
||
);
|
||
}
|
||
|
||
NtClose(BaseHandle);
|
||
|
||
//
|
||
// Check processor steppings.
|
||
//
|
||
|
||
if (i == 0) {
|
||
|
||
P0L2Size = ThisProcessorL2Size;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Check all processors against processor 0. Compare
|
||
// CPUID supported,
|
||
// Vendor ID String
|
||
// Family and Stepping
|
||
// L2 cache size.
|
||
//
|
||
|
||
if (Prcb->CpuID) {
|
||
if (strcmp(Prcb->VendorString,
|
||
KiProcessorBlock[0]->VendorString)) {
|
||
CmProcessorMismatch |= CM_PROCESSOR_MISMATCH_VENDOR;
|
||
}
|
||
if (ThisProcessorL2Size != P0L2Size) {
|
||
CmProcessorMismatch |= CM_PROCESSOR_MISMATCH_L2;
|
||
}
|
||
if ((Prcb->CpuType != KiProcessorBlock[0]->CpuType) ||
|
||
(Prcb->CpuStep != KiProcessorBlock[0]->CpuStep)) {
|
||
CmProcessorMismatch |= CM_PROCESSOR_MISMATCH_STEPPING;
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// If this processor doesn't support CPUID, P0
|
||
// shouldn't support it either.
|
||
//
|
||
|
||
if (KiProcessorBlock[0]->CpuID) {
|
||
CmProcessorMismatch |= CM_PROCESSOR_MISMATCH_STEPPING;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (0 != CmpConfigurationData) {
|
||
ExFreePool((PVOID)CmpConfigurationData);
|
||
}
|
||
}
|
||
|
||
//
|
||
// Next we try to collect System BIOS date and version strings.
|
||
//
|
||
|
||
//
|
||
// Open a physical memory section to map in physical memory.
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&SectionName,
|
||
L"\\Device\\PhysicalMemory"
|
||
);
|
||
|
||
InitializeObjectAttributes(
|
||
&ObjectAttributes,
|
||
&SectionName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
(HANDLE) NULL,
|
||
(PSECURITY_DESCRIPTOR) NULL
|
||
);
|
||
|
||
Status = ZwOpenSection(
|
||
&SectionHandle,
|
||
SECTION_ALL_ACCESS,
|
||
&ObjectAttributes
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
|
||
//
|
||
// If fail, forget the bios data and version
|
||
//
|
||
|
||
goto AllDone;
|
||
}
|
||
|
||
//
|
||
// Examine the first page of physical memory for int 10 segment
|
||
// address.
|
||
//
|
||
|
||
BaseAddress = 0;
|
||
ViewSize = 0x1000;
|
||
ViewBase.LowPart = 0;
|
||
ViewBase.HighPart = 0;
|
||
|
||
Status =ZwMapViewOfSection(
|
||
SectionHandle,
|
||
NtCurrentProcess(),
|
||
&BaseAddress,
|
||
0,
|
||
ViewSize,
|
||
&ViewBase,
|
||
&ViewSize,
|
||
ViewUnmap,
|
||
MEM_DOS_LIM,
|
||
PAGE_READWRITE
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
VideoBiosStart = VIDEO_BIOS_START;
|
||
} else {
|
||
VideoBiosStart = (*((PULONG)BaseAddress + INT10_VECTOR) & 0xFFFF0000) >> 12;
|
||
VideoBiosStart += (*((PULONG)BaseAddress + INT10_VECTOR) & 0x0000FFFF);
|
||
VideoBiosStart &= 0xffff8000;
|
||
if (VideoBiosStart < VIDEO_BIOS_START) {
|
||
VideoBiosStart = VIDEO_BIOS_START;
|
||
}
|
||
Status = ZwUnmapViewOfSection(
|
||
NtCurrentProcess(),
|
||
BaseAddress
|
||
);
|
||
}
|
||
|
||
VersionStrings = ExAllocatePool(PagedPool, VERSION_DATA_LENGTH);
|
||
BaseAddress = 0;
|
||
ViewSize = SYSTEM_BIOS_LENGTH;
|
||
ViewBase.LowPart = SYSTEM_BIOS_START;
|
||
ViewBase.HighPart = 0;
|
||
|
||
Status =ZwMapViewOfSection(
|
||
SectionHandle,
|
||
NtCurrentProcess(),
|
||
&BaseAddress,
|
||
0,
|
||
ViewSize,
|
||
&ViewBase,
|
||
&ViewSize,
|
||
ViewUnmap,
|
||
MEM_DOS_LIM,
|
||
PAGE_READWRITE
|
||
);
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
if (CmpGetBiosDate(BaseAddress, SYSTEM_BIOS_LENGTH, Buffer, TRUE)) {
|
||
|
||
//
|
||
// Convert ascii date string to unicode string and
|
||
// store it in registry.
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"SystemBiosDate"
|
||
);
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
Buffer
|
||
);
|
||
|
||
RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_SZ,
|
||
ValueData.Buffer,
|
||
ValueData.Length + sizeof( UNICODE_NULL )
|
||
);
|
||
|
||
RtlFreeUnicodeString(&ValueData);
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
|
||
memcpy(Buffer, (PCHAR)BaseAddress + 0xFFF5, 8);
|
||
Buffer[8] = '\0';
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
Buffer
|
||
);
|
||
|
||
Status = RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
|
||
Status = NtSetValueKey(
|
||
BiosInfo,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_SZ,
|
||
ValueData.Buffer,
|
||
ValueData.Length + sizeof( UNICODE_NULL )
|
||
);
|
||
|
||
RtlFreeUnicodeString(&ValueData);
|
||
}
|
||
|
||
NtClose (BiosInfo);
|
||
|
||
#endif
|
||
|
||
}
|
||
|
||
if ((VersionPointer = VersionStrings) != NULL) {
|
||
|
||
//
|
||
// Try to detect ALL the possible BIOS version strings.
|
||
//
|
||
|
||
for (VersionPass = 0; ; VersionPass++) {
|
||
|
||
if (VersionPass == 0) {
|
||
|
||
//
|
||
// First try to get the version from ACPI tables.
|
||
//
|
||
|
||
if (!CmpGetAcpiBiosVersion(Buffer)) {
|
||
|
||
//
|
||
// This is a non-ACPI system.
|
||
//
|
||
continue;
|
||
}
|
||
} else {
|
||
|
||
if (!CmpGetBiosVersion((VersionPass == 1)? BaseAddress : NULL, (VersionPass == 1)? SYSTEM_BIOS_LENGTH : 0, Buffer)) {
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Convert to unicode strings and copy them to our
|
||
// VersionStrings buffer.
|
||
//
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
Buffer
|
||
);
|
||
|
||
RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
Length = ValueData.Length + sizeof(UNICODE_NULL);
|
||
RtlCopyMemory(VersionPointer,
|
||
ValueData.Buffer,
|
||
Length
|
||
);
|
||
VersionsLength += Length;
|
||
RtlFreeUnicodeString(&ValueData);
|
||
if (VersionsLength + (MAXIMUM_BIOS_VERSION_LENGTH +
|
||
sizeof(UNICODE_NULL)) * 2 > PAGE_SIZE) {
|
||
break;
|
||
}
|
||
VersionPointer += Length;
|
||
}
|
||
|
||
//
|
||
// If we found any version string, write it to the registry.
|
||
//
|
||
|
||
if (VersionsLength != 0) {
|
||
|
||
//
|
||
// Append a UNICODE_NULL to the end of VersionStrings
|
||
//
|
||
|
||
*(PWSTR)VersionPointer = UNICODE_NULL;
|
||
VersionsLength += sizeof(UNICODE_NULL);
|
||
|
||
//
|
||
// If any version string is found, we set up a ValueName and
|
||
// initialize its value to the string(s) we found.
|
||
//
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"SystemBiosVersion"
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_MULTI_SZ,
|
||
VersionStrings,
|
||
VersionsLength
|
||
);
|
||
}
|
||
}
|
||
ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
|
||
}
|
||
|
||
//
|
||
// Get system information like SealedCaseSystem, LegacyFreeSystem etc from
|
||
// the BIOS.
|
||
//
|
||
if (CmpGetAcpiBiosInformation(&AcpiBiosInformation)) {
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"BootArchitecture"
|
||
);
|
||
|
||
NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&AcpiBiosInformation.BootArchitecture,
|
||
sizeof(ULONG)
|
||
);
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"PreferredProfile"
|
||
);
|
||
|
||
NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&AcpiBiosInformation.PreferredProfile,
|
||
sizeof(ULONG)
|
||
);
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"Capabilities"
|
||
);
|
||
|
||
NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_DWORD,
|
||
&AcpiBiosInformation.Capabilities,
|
||
sizeof(ULONG)
|
||
);
|
||
}
|
||
|
||
//
|
||
// Next we try to collect Video BIOS date and version strings.
|
||
//
|
||
|
||
BaseAddress = 0;
|
||
ViewSize = VIDEO_BIOS_LENGTH;
|
||
ViewBase.LowPart = VideoBiosStart;
|
||
ViewBase.HighPart = 0;
|
||
|
||
Status =ZwMapViewOfSection(
|
||
SectionHandle,
|
||
NtCurrentProcess(),
|
||
&BaseAddress,
|
||
0,
|
||
ViewSize,
|
||
&ViewBase,
|
||
&ViewSize,
|
||
ViewUnmap,
|
||
MEM_DOS_LIM,
|
||
PAGE_READWRITE
|
||
);
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
if (CmpGetBiosDate(BaseAddress, VIDEO_BIOS_LENGTH, Buffer, FALSE)) {
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"VideoBiosDate"
|
||
);
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
Buffer
|
||
);
|
||
|
||
RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_SZ,
|
||
ValueData.Buffer,
|
||
ValueData.Length + sizeof( UNICODE_NULL )
|
||
);
|
||
|
||
RtlFreeUnicodeString(&ValueData);
|
||
}
|
||
|
||
if (VersionStrings && CmpGetBiosVersion(BaseAddress, VIDEO_BIOS_LENGTH, Buffer)) {
|
||
VersionPointer = VersionStrings;
|
||
do {
|
||
|
||
//
|
||
// Try to detect ALL the possible BIOS version strings.
|
||
// Convert them to unicode strings and copy them to our
|
||
// VersionStrings buffer.
|
||
//
|
||
|
||
RtlInitAnsiString(
|
||
&AnsiString,
|
||
Buffer
|
||
);
|
||
|
||
RtlAnsiStringToUnicodeString(
|
||
&ValueData,
|
||
&AnsiString,
|
||
TRUE
|
||
);
|
||
|
||
Length = ValueData.Length + sizeof(UNICODE_NULL);
|
||
RtlCopyMemory(VersionPointer,
|
||
ValueData.Buffer,
|
||
Length
|
||
);
|
||
VersionsLength += Length;
|
||
RtlFreeUnicodeString(&ValueData);
|
||
if (VersionsLength + (MAXIMUM_BIOS_VERSION_LENGTH +
|
||
sizeof(UNICODE_NULL)) * 2 > PAGE_SIZE) {
|
||
break;
|
||
}
|
||
VersionPointer += Length;
|
||
} while (CmpGetBiosVersion(NULL, 0, Buffer));
|
||
|
||
if (VersionsLength != 0) {
|
||
|
||
//
|
||
// Append a UNICODE_NULL to the end of VersionStrings
|
||
//
|
||
|
||
*(PWSTR)VersionPointer = UNICODE_NULL;
|
||
VersionsLength += sizeof(UNICODE_NULL);
|
||
|
||
RtlInitUnicodeString(
|
||
&ValueName,
|
||
L"VideoBiosVersion"
|
||
);
|
||
|
||
Status = NtSetValueKey(
|
||
ParentHandle,
|
||
&ValueName,
|
||
TITLE_INDEX_VALUE,
|
||
REG_MULTI_SZ,
|
||
VersionStrings,
|
||
VersionsLength
|
||
);
|
||
}
|
||
}
|
||
ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
|
||
}
|
||
ZwClose(SectionHandle);
|
||
if (VersionStrings) {
|
||
ExFreePool((PVOID)VersionStrings);
|
||
}
|
||
|
||
AllDone:
|
||
|
||
NtClose (ParentHandle);
|
||
|
||
//
|
||
// Add any other x86 specific code here...
|
||
//
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
|
||
//
|
||
// Do machine identification.
|
||
//
|
||
|
||
CmpPerformMachineIdentification(LoaderBlock);
|
||
|
||
#endif
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
#ifdef _WANT_MACHINE_IDENTIFICATION
|
||
|
||
VOID
|
||
CmpPerformMachineIdentification(
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
{
|
||
ULONG majorVersion;
|
||
ULONG minorVersion;
|
||
CHAR versionBuffer[64];
|
||
PCHAR major;
|
||
PCHAR minor;
|
||
ULONG minSize;
|
||
|
||
major = strcpy(versionBuffer, VER_PRODUCTVERSION_STR);
|
||
minor = strchr(major, '.');
|
||
majorVersion = atoi(major);
|
||
if( minor != NULL ) {
|
||
*minor++ = '\0';
|
||
minorVersion = atoi(minor);
|
||
} else {
|
||
minorVersion = 0;
|
||
}
|
||
if ( LoaderBlock->Extension->MajorVersion > majorVersion ||
|
||
(LoaderBlock->Extension->MajorVersion == majorVersion &&
|
||
LoaderBlock->Extension->MinorVersion >= minorVersion)) {
|
||
|
||
minSize = FIELD_OFFSET(LOADER_PARAMETER_EXTENSION, InfFileSize) + sizeof(ULONG);
|
||
if (LoaderBlock->Extension && LoaderBlock->Extension->Size >= minSize) {
|
||
|
||
if (LoaderBlock->Extension->InfFileImage && LoaderBlock->Extension->InfFileSize) {
|
||
|
||
CmpMatchInfList(
|
||
LoaderBlock->Extension->InfFileImage,
|
||
LoaderBlock->Extension->InfFileSize,
|
||
"MachineDescription"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif
|