init386.c File Reference

#include "cmp.h"
#include "stdio.h"

Go to the source code of this file.

Defines
#define	TITLE_INDEX_VALUE   0
#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
#define	CPUID_PROCESSOR_NAME_STRING_SZ   49
#define	CPUID_EXTFN_BASE   0x80000000
#define	CPUID_EXTFN_PROCESSOR_NAME   0x80000002
#define	CM_PROCESSOR_MISMATCH_VENDOR   0x01
#define	CM_PROCESSOR_MISMATCH_STEPPING   0x02
#define	CM_PROCESSOR_MISMATCH_L2   0x04
#define	IS_DIGIT(c)   ((c) >= '0' && (c) <= '9')
Functions
BOOLEAN	CmpGetBiosVersion (PCHAR SearchArea, ULONG SearchLength, PCHAR VersionString)
BOOLEAN	CmpGetBiosDate (PCHAR SearchArea, ULONG SearchLength, PCHAR DateString, BOOLEAN SystemBiosDate)
ULONG	Ke386CyrixId (VOID)
NTSTATUS	CmpInitializeMachineDependentConfiguration (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Variables
PCHAR	SearchStrings []
PCHAR	BiosBegin
PCHAR	Start
PCHAR	End
UCHAR	CmpID1 []
UCHAR	CmpID2 []
WCHAR	CmpVendorID []
WCHAR	CmpProcessorNameString []
WCHAR	CmpFeatureBits []
WCHAR	CmpMHz []
WCHAR	CmpUpdateSignature []
WCHAR	CmPhysicalAddressExtension []
UCHAR	CmpCyrixID []
UCHAR	CmpIntelID []
UCHAR	CmpAmdID []
UCHAR	CmProcessorMismatch
ULONG	CmpConfigurationAreaSize
PCM_FULL_RESOURCE_DESCRIPTOR	CmpConfigurationData

---

Define Documentation

#define BIOS_DATE_LENGTH   11

Definition at line 67 of file config/i386/init386.c. Referenced by CmpGetBiosDate().

#define CM_PROCESSOR_MISMATCH_L2   0x04

Definition at line 92 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define CM_PROCESSOR_MISMATCH_STEPPING   0x02

Definition at line 91 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define CM_PROCESSOR_MISMATCH_VENDOR   0x01

Definition at line 90 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define CPUID_EXTFN_BASE   0x80000000

Definition at line 81 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define CPUID_EXTFN_PROCESSOR_NAME   0x80000002

Definition at line 82 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define CPUID_PROCESSOR_NAME_STRING_SZ   49

Definition at line 80 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define INT10_VECTOR   0x10

Definition at line 71 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define IS_DIGIT (  c   )     ((c) >= '0' && (c) <= '9')

Referenced by CmpGetBiosDate().

#define MAXIMUM_BIOS_VERSION_LENGTH   128

Definition at line 68 of file config/i386/init386.c. Referenced by CmpGetBiosVersion(), and CmpInitializeMachineDependentConfiguration().

#define SYSTEM_BIOS_LENGTH   0x10000

Definition at line 70 of file config/i386/init386.c. Referenced by CmpGetPnPBIOSTableAddress(), CmpInitializeMachineDependentConfiguration(), and CmpMatchPModeRule().

#define SYSTEM_BIOS_START   0xF0000

Definition at line 69 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define TITLE_INDEX_VALUE   0

Definition at line 45 of file config/i386/init386.c.

#define VERSION_DATA_LENGTH   PAGE_SIZE

Definition at line 74 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define VIDEO_BIOS_LENGTH   0x8000

Definition at line 73 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

#define VIDEO_BIOS_START   0xC0000

Definition at line 72 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

---

Function Documentation

BOOLEAN CmpGetBiosDate (  PCHAR  SearchArea, ULONG  SearchLength, PCHAR  DateString, BOOLEAN  SystemBiosDate )

Definition at line 141 of file config/i386/init386.c. References BIOS_DATE_LENGTH, CHAR, FALSE, IS_DIGIT, NULL, and TRUE. 00150 : 00151 00152 This routine finds the most recent date in the computer/video 00153 card's ROM. When GetRomDate encounters a datae, it checks the 00154 previously found date to see if the new date is more recent. 00155 00156 Arguments: 00157 00158 SearchArea - the area to search for a date. 00159 00160 SearchLength - Length of search. 00161 00162 DateString - Supplies a pointer to a fixed length memory to receive 00163 the date string. 00164 00165 Return Value: 00166 00167 NT_SUCCESS if a date is found. 00168 00169 --*/ 00170 00171 { 00172 CHAR prevDate[BIOS_DATE_LENGTH]; // Newest date found so far (CCYY/MM/DD) 00173 CHAR currDate[BIOS_DATE_LENGTH]; // Date currently being examined (CCYY/MM/DD) 00174 PCHAR start; // Start of the current search area. 00175 PCHAR end; // End of the search area. 00176 ULONG year; // YY 00177 ULONG month; // MM 00178 ULONG day; // DD 00179 ULONG count; 00180 00181 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') 00182 00183 // 00184 // Initialize previous date 00185 // 00186 00187 RtlZeroMemory(prevDate, BIOS_DATE_LENGTH); 00188 00189 // 00190 // We need to look ahead 5 characters to determine the 00191 // validity of the date pattern. 00192 // 00193 00194 start = SearchArea + 2; 00195 end = SearchArea + SearchLength - 5; 00196 00197 // 00198 // Process the entire search area. 00199 // 00200 00201 while (start < end) { 00202 00203 // 00204 // We consider the following byte pattern as a potential date. 00205 // We are assuming the following date pattern Month/Day/Year. 00206 // "n/nn/nn" where n is any digit. We allow month to be single 00207 // digit only. 00208 // 00209 00210 if ( start[0] == '/' && start[3] == '/' && 00211 IS_DIGIT(*(start - 1)) && 00212 IS_DIGIT(start[1]) && IS_DIGIT(start[2]) && 00213 IS_DIGIT(start[4]) && IS_DIGIT(start[5])) { 00214 00215 // 00216 // Copy MM/DD part into the currDate. 00217 // 00218 00219 RtlMoveMemory(&currDate[5], start - 2, 5); 00220 00221 // 00222 // Handle single digit month correctly. 00223 // 00224 00225 if (!IS_DIGIT(currDate[5])) { 00226 currDate[5] = '0'; 00227 } 00228 00229 // 00230 // Copy the year YY into currDate 00231 // 00232 00233 currDate[2] = start[4]; 00234 currDate[3] = start[5]; 00235 currDate[4] = currDate[7] = currDate[10] = '\0'; 00236 00237 // 00238 // Do basic validation for the date. 00239 // Only one field (YY) can be 0. 00240 // Only one field (YY) can be greater than 31. 00241 // We assume the ROM date to be in the format MM/DD/YY. 00242 // 00243 00244 year = strtoul(&currDate[2], NULL, 16); 00245 month = strtoul(&currDate[5], NULL, 16); 00246 day = strtoul(&currDate[8], NULL, 16); 00247 00248 // 00249 // Count the number of fields that are 0. 00250 // 00251 00252 count = ((day == 0)? 1 : 0) + ((month == 0)? 1 : 0) + ((year == 0)? 1 : 0); 00253 if (count <= 1) { 00254 00255 // 00256 // Count number of field that are greater than 31. 00257 // 00258 00259 count = ((day > 0x31)? 1 : 0) + ((month > 0x31)? 1 : 0) + ((year > 0x31)? 1 : 0); 00260 if (count <= 1) { 00261 00262 // 00263 // See if the ROM already has a 4 digit date. We do this only for System ROM 00264 // since they have a consistent date format. 00265 // 00266 00267 if (SystemBiosDate && IS_DIGIT(start[6]) && IS_DIGIT(start[7]) && 00268 (memcmp(&start[4], "19", 2) == 0 || memcmp(&start[4], "20", 2) == 0)) { 00269 00270 currDate[0] = start[4]; 00271 currDate[1] = start[5]; 00272 currDate[2] = start[6]; 00273 currDate[3] = start[7]; 00274 00275 } else { 00276 00277 // 00278 // Internally, we treat year as a 4 digit quantity 00279 // for comparison to determine the newest date. 00280 // We treat year YY < 80 as 20YY, otherwise 19YY. 00281 // 00282 00283 if (year < 0x80) { 00284 currDate[0] = '2'; 00285 currDate[1] = '0'; 00286 } else { 00287 currDate[0] = '1'; 00288 currDate[1] = '9'; 00289 } 00290 } 00291 00292 // 00293 // Add the '/' delimiters into the date. 00294 // 00295 00296 currDate[4] = currDate[7] = '/'; 00297 00298 // 00299 // Compare the dates, and save the newer one. 00300 // 00301 00302 if (memcmp (prevDate, currDate, BIOS_DATE_LENGTH - 1) < 0) { 00303 RtlMoveMemory(prevDate, currDate, BIOS_DATE_LENGTH - 1); 00304 } 00305 00306 // 00307 // Next search should start at the second '/'. 00308 // 00309 00310 start += 2; 00311 } 00312 } 00313 } 00314 start++; 00315 } 00316 00317 if (prevDate[0] != '\0') { 00318 00319 // 00320 // Convert from the internal CCYY/MM/DD format to 00321 // return MM/DD//YY format. 00322 // 00323 00324 RtlMoveMemory(DateString, &prevDate[5], 5); 00325 DateString[5] = '/'; 00326 DateString[6] = prevDate[2]; 00327 DateString[7] = prevDate[3]; 00328 DateString[8] = '\0'; 00329 00330 return (TRUE); 00331 } 00332 00333 // 00334 // If we did not find a date, return an empty string. 00335 // 00336 00337 DateString[0] = '\0'; 00338 return (FALSE); 00339 }

BOOLEAN CmpGetBiosVersion (  PCHAR  SearchArea, ULONG  SearchLength, PCHAR  VersionString )

Definition at line 342 of file config/i386/init386.c. References BiosBegin, Buffer, CHAR, End, FALSE, MAXIMUM_BIOS_VERSION_LENGTH, NULL, SearchStrings, Start, String, TRUE, and USHORT. : 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); }

NTSTATUS CmpInitializeMachineDependentConfiguration (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 465 of file config/i386/init386.c. References Buffer, CentralProcessor, CM_PROCESSOR_MISMATCH_L2, CM_PROCESSOR_MISMATCH_STEPPING, CM_PROCESSOR_MISMATCH_VENDOR, CmClassName, CmpConfigurationAreaSize, CmpConfigurationData, CmpCyrixID, CmpFeatureBits, CmpGetBiosDate(), CmpGetBiosVersion(), CmPhysicalAddressExtension, CmpID1, CmpID2, CmpInitializeRegistryNode(), CmpMHz, CmpProcessorNameString, CmProcessorMismatch, CmpUpdateSignature, CmpVendorID, CmRegistryMachineHardwareDescriptionSystemName, CmRegistryMachineSystemCurrentControlSetControlSessionManagerMemoryManagement, CPUID(), CPUID_EXTFN_BASE, CPUID_EXTFN_PROCESSOR_NAME, CPUID_PROCESSOR_NAME_STRING_SZ, ExAllocatePool, ExFreePool(), FALSE, FloatingPointProcessor, INT10_VECTOR, Ke386CyrixId(), KeGetPcr, KeI386NpxPresent, KeNumberProcessors, KeRevertToUserAffinityThread(), KeSetSystemAffinityThread(), KeyName, KiProcessorBlock, L, MAXIMUM_BIOS_VERSION_LENGTH, NT_SUCCESS, NtClose(), NtCreateKey(), NtOpenKey(), NtSetValueKey(), NTSTATUS(), NULL, NUMBER_TYPES, ObjectAttributes, PAGE_SIZE, PagedPool, ProcessorClass, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), RtlInitUnicodeString(), sprintf(), Status, strlen(), SYSTEM_BIOS_LENGTH, SYSTEM_BIOS_START, TITLE_INDEX_VALUE, TRUE, USHORT, ValueName, VERSION_DATA_LENGTH, VIDEO_BIOS_LENGTH, and VIDEO_BIOS_START. : 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; 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; 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; #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 = NtOpenKey( &ParentHandle, KEY_READ, &ObjectAttributes ); 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, 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 == 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 = 1 << 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 = 1 << 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 (!Prcb->CpuID) { // // Test for Cyrix processor // if (Ke386CyrixId ()) { VendorID = CmpCyrixID; } } else { // // 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. // BUGBUG This code should be moved to ntdetect.com after product 1. // // // 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 (VersionStrings && CmpGetBiosVersion(BaseAddress, SYSTEM_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); RtlMoveMemory(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); // // 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); } // // 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); RtlMoveMemory(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; }

ULONG Ke386CyrixId (  VOID   )

Definition at line 91 of file cyrix.c. References c, CCR0, CCR3, CmpCyrixID, DIR0, KeGetCurrentPrcb, ReadCyrixRegister(), and WriteCyrixRegister(). : Detects and returns the Cyrix ID of the processor. This function only detects Cyrix processors which have internal cache support. Arguments: Configure - If TRUE, causes this function to alter the Cyrix CCR registers for the optimal NT performance. If FALSE, the processors configuration is not altered. Return Value: Cyrix ID of the processor 0 if not a Cyrix processor --*/ { ULONG CyrixID; UCHAR r3, c; UCHAR flags; PKPRCB Prcb; CyrixID = 0; Prcb = KeGetCurrentPrcb(); if (Prcb->CpuID && strcmp (Prcb->VendorString, CmpCyrixID)) { // // Not a Cyrix processor // return 0; } // // Test Div instruction to see if the flags // do not get altered // _asm { xor eax, eax sahf ; flags = ah lahf ; ah = flags mov flags, ah ; save flags mov eax, 5 mov ecx, 2 div cl ; 5 / 2 = ? lahf sub flags, ah ; flags = orig_flags - new_flags } if (flags == 0) { // // See if the Cyrix CCR3 register bit 0x80 can be editted. // r3 = ReadCyrixRegister(CCR3); // Read CCR3 c = r3 ^ 0x80; // flip bit 80 WriteCyrixRegister(CCR3, c); // Write CCR3 ReadCyrixRegister(CCR0); // select new register c = ReadCyrixRegister(CCR3); // Read new CCR3 value if (ReadCyrixRegister(CCR3) != r3) { // // Read the Cyrix ID type register // CyrixID = ReadCyrixRegister(DIR0) + 1; } WriteCyrixRegister(CCR3, r3); // restore original CCR3 value } if (CyrixID > 0x7f) { // invalid setting CyrixID = 0; } return CyrixID; }

---

Variable Documentation

PCHAR BiosBegin

Definition at line 48 of file config/i386/init386.c. Referenced by CmpGetBiosVersion().

UCHAR CmpAmdID[]

Definition at line 61 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration(), and KiGetCpuVendor().

ULONG CmpConfigurationAreaSize

Definition at line 95 of file config/i386/init386.c.

PCM_FULL_RESOURCE_DESCRIPTOR CmpConfigurationData

Definition at line 96 of file config/i386/init386.c.

UCHAR CmpCyrixID[]

Definition at line 59 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration(), Ke386CyrixId(), and KiGetCpuVendor().

WCHAR CmpFeatureBits[]

Definition at line 55 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

WCHAR CmPhysicalAddressExtension[]

Definition at line 58 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

UCHAR CmpID1[]

Definition at line 51 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

UCHAR CmpID2[]

Definition at line 52 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

UCHAR CmpIntelID[]

Definition at line 60 of file config/i386/init386.c. Referenced by KiGetCpuVendor().

WCHAR CmpMHz[]

Definition at line 56 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

WCHAR CmpProcessorNameString[]

Definition at line 54 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

UCHAR CmProcessorMismatch

Definition at line 88 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

WCHAR CmpUpdateSignature[]

Definition at line 57 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

WCHAR CmpVendorID[]

Definition at line 53 of file config/i386/init386.c. Referenced by CmpInitializeMachineDependentConfiguration().

PCHAR End

Definition at line 50 of file config/i386/init386.c. Referenced by ArbAddOrdering(), ArbPruneOrdering(), CalculateCHSVals(), CmpDoSort(), CmpGetBiosDate(), CmpGetBiosVersion(), CmpNameFromAttributes(), FdCrosses1024Cylinder(), HvpAllocateMap(), HvpFindNextDirtyBlock(), HvpFreeMap(), HvpRecoverData(), HvRefreshHive(), KdpSetLoadState(), KdpSetStateChange(), KeCheckForTimer(), LdrpDphInitializeTargetDll(), MiCheckSecuredVad(), MiInitializeDriverVerifierList(), MNFindItemInColumn(), RtlAddAttributeActionToRXact(), RtlAddRange(), RtlDeleteRange(), RtlFindLastBackwardRunClear(), RtlFindNextForwardRunClear(), RtlIsRangeAvailable(), RtlpCreateRangeListEntry(), RtlpIsRangeAvailable(), and UserGlobalAtomTableCallout().

PCHAR SearchStrings[]

Definition at line 47 of file config/i386/init386.c. Referenced by CmpGetBiosVersion().

PCHAR Start

Definition at line 49 of file config/i386/init386.c. Referenced by ArbAddOrdering(), ArbPruneOrdering(), CalculateCHSVals(), CmpGetBiosDate(), CmpGetBiosVersion(), FdCrosses1024Cylinder(), HvFreeHivePartial(), HvMarkClean(), HvMarkDirty(), HvpAllocateMap(), HvpFindNextDirtyBlock(), HvpFreeMap(), HvpRecoverData(), HvRefreshHive(), InitializeFreeSpace(), IopBusNumberPackResource(), IopBusNumberUnpackResource(), IopDmaPackResource(), IopDmaUnpackResource(), IopGenericPackResource(), IopGenericUnpackResource(), IopIrqPackResource(), IopIrqUnpackResource(), KeCheckForTimer(), MiInitializeDriverVerifierList(), NtAllocateVirtualMemory(), PspQueryLdtInformation(), RtlAddRange(), RtlDeleteRange(), RtlFindLastBackwardRunClear(), RtlFindNextForwardRunClear(), RtlFindRange(), RtlIsRangeAvailable(), RtlpCreateRangeListEntry(), and RtlpIsRangeAvailable().

---