ReactOS 0.4.16-dev-1506-g117cd33
Macros | Functions | Variables
cmhardwr.c File Reference
#include "ntoskrnl.h"
#include "debug.h"
Include dependency graph for cmhardwr.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

BOOLEAN NTAPI CmpGetBiosDate (IN PCHAR BiosStart, IN ULONG BiosLength, IN PCHAR BiosDate, IN BOOLEAN FromBios)
 
BOOLEAN NTAPI CmpGetBiosVersion (IN PCHAR BiosStart, IN ULONG BiosLength, IN PCHAR BiosVersion)
 
NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 

Variables

PCHAR CmpFullCpuID = "%s Family %u Model %u Stepping %u"
 
PCHAR CmpBiosStrings []
 
PCHAR CmpBiosBegin
 
PCHAR CmpBiosSearchStart
 
PCHAR CmpBiosSearchEnd
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file cmhardwr.c.

Function Documentation

◆ CmpGetBiosDate()

BOOLEAN NTAPI CmpGetBiosDate ( IN PCHAR  BiosStart,
IN ULONG  BiosLength,
IN PCHAR  BiosDate,
IN BOOLEAN  FromBios 
)

Definition at line 34 of file cmhardwr.c.

38{
39 CHAR LastDate[11] = {0}, CurrentDate[11];
40 PCHAR p, pp;
41
42 /* Skip the signature and the magic, and loop the BIOS ROM */
43 p = BiosStart + 2;
44 pp = BiosStart + BiosLength - 5;
45 while (p < pp)
46 {
47 /* Check for xx/yy/zz which we assume to be a date */
48 if ((p[0] == '/') &&
49 (p[3] == '/') &&
50 (isdigit(p[-1])) &&
51 (isdigit(p[1])) &&
52 (isdigit(p[2])) &&
53 (isdigit(p[4])) &&
54 (isdigit(p[5])))
55 {
56 /* Copy the string proper */
57 RtlMoveMemory(&CurrentDate[5], p - 2, 5);
58
59 /* Add a 0 if the month only has one digit */
60 if (!isdigit(CurrentDate[5])) CurrentDate[5] = '0';
61
62 /* Now copy the year */
63 CurrentDate[2] = p[4];
64 CurrentDate[3] = p[5];
65 CurrentDate[4] = CurrentDate[7] = CurrentDate[10] = ANSI_NULL;
66
67 /* If the date comes from the BIOS, check if it's a 4-digit year */
68 if ((FromBios) &&
69 (isdigit(p[6])) &&
70 (isdigit(p[7])) &&
71 ((RtlEqualMemory(&p[4], "19", 2)) ||
72 (RtlEqualMemory(&p[4], "20", 2))))
73 {
74 /* Copy the year proper */
75 CurrentDate[0] = p[4];
76 CurrentDate[1] = p[5];
77 CurrentDate[2] = p[6];
78 CurrentDate[3] = p[7];
79 }
80 else
81 {
82 /* Otherwise, we'll just assume anything under 80 is 2000 */
83 if (strtoul(&CurrentDate[2], NULL, 10) < 80)
84 {
85 /* Hopefully your BIOS wasn't made in 1979 */
86 CurrentDate[0] = '2';
87 CurrentDate[1] = '0';
88 }
89 else
90 {
91 /* Anything over 80, was probably made in the 1900s... */
92 CurrentDate[0] = '1';
93 CurrentDate[1] = '9';
94 }
95 }
96
97 /* Add slashes where we previously had NULLs */
98 CurrentDate[4] = CurrentDate[7] = '/';
99
100 /* Check which date is newer */
101 if (memcmp(LastDate, CurrentDate, 10) < 0)
102 {
103 /* Found a newer date, select it */
104 RtlMoveMemory(LastDate, CurrentDate, 10);
105 }
106
107 p += 2;
108 }
109 p++;
110 }
111
112 /* Make sure we found a date */
113 if (LastDate[0])
114 {
115 /* Copy the year at the pp, and keep only the last two digits */
116 RtlMoveMemory(BiosDate, &LastDate[5], 5);
117 BiosDate[5] = '/';
118 BiosDate[6] = LastDate[2];
119 BiosDate[7] = LastDate[3];
120 BiosDate[8] = ANSI_NULL;
121 return TRUE;
122 }
123
124 /* No date found, return empty string */
125 BiosDate[0] = ANSI_NULL;
126 return FALSE;
127}
strtoul
UINT32 strtoul(const char *String, char **Terminator, UINT32 Base)
Definition: utclib.c:696
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
isdigit
#define isdigit(c)
Definition: acclib.h:68
BiosDate
static const CHAR BiosDate[]
Definition: bios32.c:141
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
p
GLfloat GLfloat p
Definition: glext.h:8902
RtlEqualMemory
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
ANSI_NULL
#define ANSI_NULL
RtlMoveMemory
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
PCHAR
char * PCHAR
Definition: typedefs.h:51
CHAR
char CHAR
Definition: xmlstorage.h:175

Referenced by CmpInitializeMachineDependentConfiguration().

◆ CmpGetBiosVersion()

BOOLEAN NTAPI CmpGetBiosVersion ( IN PCHAR  BiosStart,
IN ULONG  BiosLength,
IN PCHAR  BiosVersion 
)

Definition at line 131 of file cmhardwr.c.

134{
135 CHAR Buffer[128];
136 PCHAR p, pp;
137 USHORT i;
138
139 /* Check if we were given intitial data for the search */
140 if (BiosStart)
141 {
142 /* Save it for later use */
143 CmpBiosBegin = BiosStart;
144 CmpBiosSearchStart = BiosStart + 1;
145 CmpBiosSearchEnd = BiosStart + BiosLength - 2;
146 }
147
148 /* Now loop the BIOS area */
149 for (;;)
150 {
151 /* Start an initial search looking for numbers and periods */
152 pp = NULL;
153 while (CmpBiosSearchStart <= CmpBiosSearchEnd)
154 {
155 /* Check if we have an "x.y" version string */
156 if ((*CmpBiosSearchStart == '.') &&
157 (*(CmpBiosSearchStart + 1) >= '0') &&
158 (*(CmpBiosSearchStart + 1) <= '9') &&
159 (*(CmpBiosSearchStart - 1) >= '0') &&
160 (*(CmpBiosSearchStart - 1) <= '9'))
161 {
162 /* Start looking in this area for the actual BIOS Version */
163 pp = CmpBiosSearchStart;
164 break;
165 }
166 else
167 {
168 /* Keep searching */
169 CmpBiosSearchStart++;
170 }
171 }
172
173 /* Break out if we're went past the BIOS area */
174 if (CmpBiosSearchStart > CmpBiosSearchEnd) return FALSE;
175
176 /* Move to the next 2 bytes */
177 CmpBiosSearchStart += 2;
178
179 /* Null-terminate our scratch buffer and start the string here */
180 Buffer[127] = ANSI_NULL;
181 p = &Buffer[127];
182
183 /* Go back one character since we're doing this backwards */
184 pp--;
185
186 /* Loop the identifier we found as long as it's valid */
187 i = 0;
188 while ((i++ < 127) &&
189 (pp >= CmpBiosBegin) &&
190 (*pp >= ' ') &&
191 (*pp != '$'))
192 {
193 /* Copy the character */
194 *--p = *pp--;
195 }
196
197 /* Go past the last character since we went backwards */
198 pp++;
199
200 /* Loop the strings we recognize */
201 for (i = 0; CmpBiosStrings[i]; i++)
202 {
203 /* Check if a match was found */
204 if (strstr(p, CmpBiosStrings[i])) goto Match;
205 }
206 }
207
208Match:
209 /* Skip until we find a space */
210 for (; *pp == ' '; pp++);
211
212 /* Loop the final string */
213 i = 0;
214 do
215 {
216 /* Copy the character into the final string */
217 BiosVersion[i] = *pp++;
218 } while ((++i < 127) &&
219 (pp <= (CmpBiosSearchEnd + 1)) &&
220 (*pp >= ' ') &&
221 (*pp != '$'));
222
223 /* Null-terminate the version string */
224 BiosVersion[i] = ANSI_NULL;
225 return TRUE;
226}
strstr
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
BiosVersion
static const CHAR BiosVersion[]
Definition: bios32.c:139
Buffer
Definition: bufpool.h:45
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
CmpBiosSearchEnd
PCHAR CmpBiosSearchEnd
Definition: cmhardwr.c:28
CmpBiosBegin
PCHAR CmpBiosBegin
Definition: cmhardwr.c:28
CmpBiosSearchStart
PCHAR CmpBiosSearchStart
Definition: cmhardwr.c:28
CmpBiosStrings
PCHAR CmpBiosStrings[]
Definition: cmhardwr.c:18
USHORT
unsigned short USHORT
Definition: pedump.c:61

Referenced by CmpInitializeMachineDependentConfiguration().

◆ CmpInitializeMachineDependentConfiguration()

NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 230 of file cmhardwr.c.

231{
232 UNICODE_STRING KeyName, ValueName, Data, SectionName;
233 OBJECT_ATTRIBUTES ObjectAttributes;
234 ULONG HavePae, Length, TotalLength = 0, i, Disposition;
235 SIZE_T ViewSize;
236 NTSTATUS Status;
237 HANDLE KeyHandle, BiosHandle, SystemHandle, FpuHandle, SectionHandle;
238 CONFIGURATION_COMPONENT_DATA ConfigData;
239 CHAR Buffer[128];
240 CPU_INFO CpuInfo;
241 ULONG ExtendedId;
242 PKPRCB Prcb;
243 USHORT IndexTable[MaximumType + 1] = {0};
244 ANSI_STRING TempString;
245 PCHAR PartialString = NULL, BiosVersion;
246 CHAR CpuString[48];
247 PVOID BaseAddress = NULL;
248 LARGE_INTEGER ViewBase = {{0, 0}};
249 ULONG_PTR VideoRomBase;
250 PCHAR CurrentVersion;
251 extern UNICODE_STRING KeRosProcessorName, KeRosBiosDate, KeRosBiosVersion;
252 extern UNICODE_STRING KeRosVideoBiosDate, KeRosVideoBiosVersion;
253
254 /* Open the SMSS Memory Management key */
255 RtlInitUnicodeString(&KeyName,
256 L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
257 L"Control\\Session Manager\\Memory Management");
258 InitializeObjectAttributes(&ObjectAttributes,
259 &KeyName,
260 OBJ_CASE_INSENSITIVE,
261 NULL,
262 NULL);
263 Status = NtOpenKey(&KeyHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
264 if (NT_SUCCESS(Status))
265 {
266 /* Detect if PAE is enabled */
267 HavePae = SharedUserData->ProcessorFeatures[PF_PAE_ENABLED];
268
269 /* Set the value */
270 RtlInitUnicodeString(&ValueName, L"PhysicalAddressExtension");
271 NtSetValueKey(KeyHandle,
272 &ValueName,
273 0,
274 REG_DWORD,
275 &HavePae,
276 sizeof(HavePae));
277
278 /* Close the key */
279 NtClose(KeyHandle);
280 }
281
282 /* Open the hardware description key */
283 RtlInitUnicodeString(&KeyName,
284 L"\\Registry\\Machine\\Hardware\\Description\\System");
285 InitializeObjectAttributes(&ObjectAttributes,
286 &KeyName,
287 OBJ_CASE_INSENSITIVE,
288 NULL,
289 NULL);
290 Status = NtOpenKey(&SystemHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
291 if (!NT_SUCCESS(Status))
292 return Status;
293
294 /* Create the BIOS Information key */
295 RtlInitUnicodeString(&KeyName,
296 L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
297 L"Control\\BIOSINFO");
298 InitializeObjectAttributes(&ObjectAttributes,
299 &KeyName,
300 OBJ_CASE_INSENSITIVE,
301 NULL,
302 NULL);
303 Status = NtCreateKey(&BiosHandle,
304 KEY_ALL_ACCESS,
305 &ObjectAttributes,
306 0,
307 NULL,
308 REG_OPTION_NON_VOLATILE,
309 &Disposition);
310 if (!NT_SUCCESS(Status))
311 {
312 NtClose(SystemHandle);
313 return Status;
314 }
315
316 /* Create the CPU Key, and check if it already existed */
317 RtlInitUnicodeString(&KeyName, L"CentralProcessor");
318 InitializeObjectAttributes(&ObjectAttributes,
319 &KeyName,
320 OBJ_CASE_INSENSITIVE,
321 SystemHandle,
322 NULL);
323 Status = NtCreateKey(&KeyHandle,
324 KEY_READ | KEY_WRITE,
325 &ObjectAttributes,
326 0,
327 NULL,
328 0,
329 &Disposition);
330 NtClose(KeyHandle);
331
332 /* The key shouldn't already exist */
333 if (Disposition == REG_CREATED_NEW_KEY)
334 {
335 /* Allocate the configuration data for cmconfig.c */
336 CmpConfigurationData = ExAllocatePoolWithTag(PagedPool,
337 CmpConfigurationAreaSize,
338 TAG_CM);
339 if (!CmpConfigurationData)
340 {
341 // FIXME: Cleanup stuff!!
342 return STATUS_INSUFFICIENT_RESOURCES;
343 }
344
345 /* Loop all CPUs */
346 for (i = 0; i < KeNumberProcessors; i++)
347 {
348#ifdef _M_AMD64
349 PCHAR FamilyId;
350#endif
351 /* Get the PRCB */
352 Prcb = KiProcessorBlock[i];
353
354 /* Setup the Configuration Entry for the Processor */
355 RtlZeroMemory(&ConfigData, sizeof(ConfigData));
356 ConfigData.ComponentEntry.Class = ProcessorClass;
357 ConfigData.ComponentEntry.Type = CentralProcessor;
358 ConfigData.ComponentEntry.Key = i;
359 ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
360 ConfigData.ComponentEntry.Identifier = Buffer;
361
362#if defined(_M_IX86)
363 /* Check if the CPU doesn't support CPUID */
364 if (!Prcb->CpuID)
365 {
366 /* Build 80x86-style string for older CPUs */
367 sprintf(Buffer,
368 "80%u86-%c%x",
369 Prcb->CpuType,
370 (Prcb->CpuStep >> 8) + 'A',
371 Prcb->CpuStep & 0xff);
372 }
373 else
374 {
375 /* Build full ID string for newer CPUs */
376 sprintf(Buffer,
377 CmpFullCpuID,
378 "x86",
379 Prcb->CpuType,
380 (Prcb->CpuStep >> 8),
381 Prcb->CpuStep & 0xff);
382 }
383#elif defined(_M_AMD64)
384 if (Prcb->CpuVendor == CPU_VIA)
385 {
386 /* This is VIA64 family */
387 FamilyId = "VIA64";
388 }
389 else if (Prcb->CpuVendor == CPU_AMD)
390 {
391 /* This is AMD64 family */
392 FamilyId = "AMD64";
393 }
394 else
395 {
396 /* This is generic EM64T family */
397 FamilyId = "EM64T";
398 }
399
400 /* ID string has the same style for all 64-bit CPUs */
401 sprintf(Buffer,
402 CmpFullCpuID,
403 FamilyId,
404 Prcb->CpuType,
405 (Prcb->CpuStep >> 8),
406 Prcb->CpuStep & 0xff);
407#else
408#error Unknown architecture
409#endif
410
411 /* Save the ID string length now that we've created it */
412 ConfigData.ComponentEntry.IdentifierLength = (ULONG)strlen(Buffer) + 1;
413
414 /* Initialize the registry configuration node for it */
415 Status = CmpInitializeRegistryNode(&ConfigData,
416 SystemHandle,
417 &KeyHandle,
418 InterfaceTypeUndefined,
419 0xFFFFFFFF,
420 IndexTable);
421 if (!NT_SUCCESS(Status))
422 {
423 NtClose(BiosHandle);
424 NtClose(SystemHandle);
425 return Status;
426 }
427
428 /* Check if we have an FPU */
429 if (KeI386NpxPresent)
430 {
431 /* Setup the Configuration Entry for the FPU */
432 RtlZeroMemory(&ConfigData, sizeof(ConfigData));
433 ConfigData.ComponentEntry.Class = ProcessorClass;
434 ConfigData.ComponentEntry.Type = FloatingPointProcessor;
435 ConfigData.ComponentEntry.Key = i;
436 ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
437 ConfigData.ComponentEntry.Identifier = Buffer;
438
439 /* For 386 cpus, the CPU pp is the identifier */
440 if (Prcb->CpuType == 3) strcpy(Buffer, "80387");
441
442 /* Save the ID string length now that we've created it */
443 ConfigData.ComponentEntry.IdentifierLength = (ULONG)strlen(Buffer) + 1;
444
445 /* Initialize the registry configuration node for it */
446 Status = CmpInitializeRegistryNode(&ConfigData,
447 SystemHandle,
448 &FpuHandle,
449 InterfaceTypeUndefined,
450 0xFFFFFFFF,
451 IndexTable);
452 if (!NT_SUCCESS(Status))
453 {
454 /* We failed, close all the opened handles and return */
455 NtClose(KeyHandle);
456 NtClose(BiosHandle);
457 NtClose(SystemHandle);
458 return Status;
459 }
460
461 /* Close this new handle */
462 NtClose(FpuHandle);
463
464 /* Stay on this CPU only */
465 KeSetSystemAffinityThread(Prcb->SetMember);
466 if (!Prcb->CpuID)
467 {
468 /* Uh oh, no CPUID! Should not happen as we don't support 80386 and older 80486 */
469 ASSERT(FALSE);
470 }
471 else
472 {
473 /* Check if we have extended CPUID that supports name ID */
474 KiCpuId(&CpuInfo, 0x80000000);
475 ExtendedId = CpuInfo.Eax;
476 if (ExtendedId >= 0x80000004)
477 {
478 /* Do all the CPUIDs required to get the full name */
479 PartialString = CpuString;
480 for (ExtendedId = 2; ExtendedId <= 4; ExtendedId++)
481 {
482 /* Do the CPUID and save the name string */
483 KiCpuId(&CpuInfo, 0x80000000 | ExtendedId);
484 ((PULONG)PartialString)[0] = CpuInfo.Eax;
485 ((PULONG)PartialString)[1] = CpuInfo.Ebx;
486 ((PULONG)PartialString)[2] = CpuInfo.Ecx;
487 ((PULONG)PartialString)[3] = CpuInfo.Edx;
488
489 /* Go to the next name string */
490 PartialString += 16;
491 }
492
493 /* Null-terminate it */
494 CpuString[47] = ANSI_NULL;
495 }
496 }
497
498 /* Go back to user affinity */
499 KeRevertToUserAffinityThread();
500
501 /* Check if we have a CPU Name */
502 if (PartialString)
503 {
504 /* Convert it to Unicode */
505 RtlInitAnsiString(&TempString, CpuString);
506 if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE)))
507 {
508 /* Add it to the registry */
509 RtlInitUnicodeString(&ValueName, L"ProcessorNameString");
510 Status = NtSetValueKey(KeyHandle,
511 &ValueName,
512 0,
513 REG_SZ,
514 Data.Buffer,
515 Data.Length + sizeof(UNICODE_NULL));
516
517 /* ROS: Save a copy for Jira reporting */
518 if (!RtlCreateUnicodeString(&KeRosProcessorName, Data.Buffer))
519 {
520 /* Do not fail for this */
521 KeRosProcessorName.Length = 0;
522 }
523
524 /* Free the temporary buffer */
525 RtlFreeUnicodeString(&Data);
526 }
527 }
528
529 /* Check if we had a Vendor ID */
530 if (Prcb->VendorString[0])
531 {
532 /* Convert it to Unicode */
533 RtlInitAnsiString(&TempString, Prcb->VendorString);
534 if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE)))
535 {
536 /* Add it to the registry */
537 RtlInitUnicodeString(&ValueName, L"VendorIdentifier");
538 Status = NtSetValueKey(KeyHandle,
539 &ValueName,
540 0,
541 REG_SZ,
542 Data.Buffer,
543 Data.Length + sizeof(UNICODE_NULL));
544
545 /* Free the temporary buffer */
546 RtlFreeUnicodeString(&Data);
547 }
548 }
549
550 /* Check if we have features bits */
551 if (Prcb->FeatureBits)
552 {
553 /* Add them to the registry */
554 RtlInitUnicodeString(&ValueName, L"FeatureSet");
555 Status = NtSetValueKey(KeyHandle,
556 &ValueName,
557 0,
558 REG_DWORD,
559 &Prcb->FeatureBits,
560 sizeof(Prcb->FeatureBits));
561 }
562
563 /* Check if we detected the CPU Speed */
564 if (Prcb->MHz)
565 {
566 /* Add it to the registry */
567 RtlInitUnicodeString(&ValueName, L"~MHz");
568 Status = NtSetValueKey(KeyHandle,
569 &ValueName,
570 0,
571 REG_DWORD,
572 &Prcb->MHz,
573 sizeof(Prcb->MHz));
574 }
575
576 /* Check if we have an update signature */
577 if (Prcb->UpdateSignature.QuadPart)
578 {
579 /* Add it to the registry */
580 RtlInitUnicodeString(&ValueName, L"Update Signature");
581 Status = NtSetValueKey(KeyHandle,
582 &ValueName,
583 0,
584 REG_BINARY,
585 &Prcb->UpdateSignature,
586 sizeof(Prcb->UpdateSignature));
587 }
588
589 /* Close the processor handle */
590 NtClose(KeyHandle);
591
592 /* FIXME: Detect CPU mismatches */
593 }
594 }
595
596 /* Free the configuration data */
597 ExFreePoolWithTag(CmpConfigurationData, TAG_CM);
598 }
599
600 /* Open physical memory */
601 RtlInitUnicodeString(&SectionName, L"\\Device\\PhysicalMemory");
602 InitializeObjectAttributes(&ObjectAttributes,
603 &SectionName,
604 OBJ_CASE_INSENSITIVE,
605 NULL,
606 NULL);
607 Status = ZwOpenSection(&SectionHandle,
608 SECTION_ALL_ACCESS,
609 &ObjectAttributes);
610 if (!NT_SUCCESS(Status))
611 {
612 /* We failed, close all the opened handles and return */
613 // NtClose(KeyHandle);
614 NtClose(BiosHandle);
615 NtClose(SystemHandle);
616 /* 'Quickie' closes KeyHandle */
617 goto Quickie;
618 }
619
620 /* Map the first 1KB of memory to get the IVT */
621 ViewSize = PAGE_SIZE;
622 Status = ZwMapViewOfSection(SectionHandle,
623 NtCurrentProcess(),
624 &BaseAddress,
625 0,
626 ViewSize,
627 &ViewBase,
628 &ViewSize,
629 ViewUnmap,
630 MEM_DOS_LIM,
631 PAGE_READWRITE);
632 if (!NT_SUCCESS(Status))
633 {
634 /* Assume default */
635 VideoRomBase = 0xC0000;
636 }
637 else
638 {
639 /* Calculate the base address from the vector */
640 VideoRomBase = (*((PULONG)BaseAddress + 0x10) >> 12) & 0xFFFF0;
641 VideoRomBase += *((PULONG)BaseAddress + 0x10) & 0xFFF0;
642
643 /* Now get to the actual ROM Start and make sure it's not invalid*/
644 VideoRomBase &= 0xFFFF8000;
645 if (VideoRomBase < 0xC0000) VideoRomBase = 0xC0000;
646
647 /* And unmap the section */
648 ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
649 }
650
651 /* Allocate BIOS Version pp Buffer */
652 BiosVersion = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM);
653
654 /* Setup settings to map the 64K BIOS ROM */
655 BaseAddress = 0;
656 ViewSize = 16 * PAGE_SIZE;
657 ViewBase.LowPart = 0xF0000;
658 ViewBase.HighPart = 0;
659
660 /* Map it */
661 Status = ZwMapViewOfSection(SectionHandle,
662 NtCurrentProcess(),
663 &BaseAddress,
664 0,
665 ViewSize,
666 &ViewBase,
667 &ViewSize,
668 ViewUnmap,
669 MEM_DOS_LIM,
670 PAGE_READWRITE);
671 if (NT_SUCCESS(Status))
672 {
673 /* Scan the ROM to get the BIOS Date */
674 if (CmpGetBiosDate(BaseAddress, 16 * PAGE_SIZE, Buffer, TRUE))
675 {
676 /* Convert it to Unicode */
677 RtlInitAnsiString(&TempString, Buffer);
678 if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE)))
679 {
680 /* Write the date into the registry */
681 RtlInitUnicodeString(&ValueName, L"SystemBiosDate");
682 Status = NtSetValueKey(SystemHandle,
683 &ValueName,
684 0,
685 REG_SZ,
686 Data.Buffer,
687 Data.Length + sizeof(UNICODE_NULL));
688
689 /* Free the string */
690 RtlFreeUnicodeString(&Data);
691 }
692
693 if (BiosHandle)
694 {
695 /* Get the BIOS Date Identifier */
696 RtlCopyMemory(Buffer, (PCHAR)BaseAddress + (16 * PAGE_SIZE - 11), 8);
697 Buffer[8] = ANSI_NULL;
698
699 /* Convert it to unicode */
700 RtlInitAnsiString(&TempString, Buffer);
701 Status = RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
702 if (NT_SUCCESS(Status))
703 {
704 /* Save it to the registry */
705 Status = NtSetValueKey(BiosHandle,
706 &ValueName,
707 0,
708 REG_SZ,
709 Data.Buffer,
710 Data.Length + sizeof(UNICODE_NULL));
711
712 /* ROS: Save a copy for Jira reporting */
713 if (!RtlCreateUnicodeString(&KeRosBiosDate, Data.Buffer))
714 KeRosBiosDate.Length = 0;
715
716 /* Free the string */
717 RtlFreeUnicodeString(&Data);
718 }
719
720 /* Close the bios information handle */
721 NtClose(BiosHandle);
722 }
723 }
724
725 /* Get the BIOS Version */
726 if (CmpGetBiosVersion(BaseAddress, 16 * PAGE_SIZE, Buffer))
727 {
728 /* Start at the beginning of our buffer */
729 CurrentVersion = BiosVersion;
730 do
731 {
732 /* Convert to Unicode */
733 RtlInitAnsiString(&TempString, Buffer);
734 Status = RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
735 if (!NT_SUCCESS(Status))
736 break;
737
738 /* Calculate the length of this string and copy it in */
739 Length = Data.Length + sizeof(UNICODE_NULL);
740 RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
741
742 /* Free the unicode string */
743 RtlFreeUnicodeString(&Data);
744
745 /* Update the total length and see if we're out of space */
746 TotalLength += Length;
747 if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
748 {
749 /* One more string would push us out, so stop here */
750 break;
751 }
752
753 /* Go to the next string inside the multi-string buffer */
754 CurrentVersion += Length;
755
756 /* Query the next BIOS Version */
757 } while (CmpGetBiosVersion(NULL, 0, Buffer));
758
759 /* Check if we found any strings at all */
760 if (TotalLength)
761 {
762 /* Add the final null-terminator */
763 *(PWSTR)CurrentVersion = UNICODE_NULL;
764 TotalLength += sizeof(UNICODE_NULL);
765
766 /* Write the BIOS Version to the registry */
767 RtlInitUnicodeString(&ValueName, L"SystemBiosVersion");
768 Status = NtSetValueKey(SystemHandle,
769 &ValueName,
770 0,
771 REG_MULTI_SZ,
772 BiosVersion,
773 TotalLength);
774
775 /* ROS: Save a copy for Jira reporting */
776 if (!RtlCreateUnicodeString(&KeRosBiosVersion, (PWCH)BiosVersion))
777 KeRosBiosVersion.Length = 0;
778 }
779 }
780
781 /* Unmap the section */
782 ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
783 }
784
785 /* Now prepare for Video BIOS Mapping of 32KB */
786 BaseAddress = 0;
787 ViewSize = 8 * PAGE_SIZE;
788 ViewBase.QuadPart = VideoRomBase;
789
790 /* Map it */
791 Status = ZwMapViewOfSection(SectionHandle,
792 NtCurrentProcess(),
793 &BaseAddress,
794 0,
795 ViewSize,
796 &ViewBase,
797 &ViewSize,
798 ViewUnmap,
799 MEM_DOS_LIM,
800 PAGE_READWRITE);
801 if (NT_SUCCESS(Status))
802 {
803 /* Scan the ROM to get the BIOS Date */
804 if (CmpGetBiosDate(BaseAddress, 8 * PAGE_SIZE, Buffer, FALSE))
805 {
806 /* Convert it to Unicode */
807 RtlInitAnsiString(&TempString, Buffer);
808 if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE)))
809 {
810 /* Write the date into the registry */
811 RtlInitUnicodeString(&ValueName, L"VideoBiosDate");
812 Status = NtSetValueKey(SystemHandle,
813 &ValueName,
814 0,
815 REG_SZ,
816 Data.Buffer,
817 Data.Length + sizeof(UNICODE_NULL));
818
819 /* ROS: Save a copy for Jira reporting */
820 if (!RtlCreateUnicodeString(&KeRosVideoBiosDate, Data.Buffer))
821 KeRosVideoBiosDate.Length = 0;
822
823 /* Free the string */
824 RtlFreeUnicodeString(&Data);
825 }
826 }
827
828 /* Get the Video BIOS Version */
829 if (CmpGetBiosVersion(BaseAddress, 8 * PAGE_SIZE, Buffer))
830 {
831 /* Start at the beginning of our buffer */
832 CurrentVersion = BiosVersion;
833 do
834 {
835 /* Convert to Unicode */
836 RtlInitAnsiString(&TempString, Buffer);
837 if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE)))
838 break;
839
840 /* Calculate the length of this string and copy it in */
841 Length = Data.Length + sizeof(UNICODE_NULL);
842 RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
843
844 /* Free the unicode string */
845 RtlFreeUnicodeString(&Data);
846
847 /* Update the total length and see if we're out of space */
848 TotalLength += Length;
849 if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
850 {
851 /* One more string would push us out, so stop here */
852 break;
853 }
854
855 /* Go to the next string inside the multi-string buffer */
856 CurrentVersion += Length;
857
858 /* Query the next BIOS Version */
859 } while (CmpGetBiosVersion(NULL, 0, Buffer));
860
861 /* Check if we found any strings at all */
862 if (TotalLength)
863 {
864 /* Add the final null-terminator */
865 *(PWSTR)CurrentVersion = UNICODE_NULL;
866 TotalLength += sizeof(UNICODE_NULL);
867
868 /* Write the BIOS Version to the registry */
869 RtlInitUnicodeString(&ValueName, L"VideoBiosVersion");
870 Status = NtSetValueKey(SystemHandle,
871 &ValueName,
872 0,
873 REG_MULTI_SZ,
874 BiosVersion,
875 TotalLength);
876
877 /* ROS: Save a copy for Jira reporting */
878 if (!RtlCreateUnicodeString(&KeRosVideoBiosVersion, (PWCH)BiosVersion))
879 KeRosVideoBiosVersion.Length = 0;
880 }
881 }
882
883 /* Unmap the section */
884 ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
885 }
886
887 /* Close the section */
888 ZwClose(SectionHandle);
889
890 /* Free the BIOS version string buffer */
891 if (BiosVersion) ExFreePoolWithTag(BiosVersion, TAG_CM);
892
893Quickie:
894 /* Close the processor handle */
895 NtClose(KeyHandle);
896 return STATUS_SUCCESS;
897}
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
KeRosVideoBiosVersion
UNICODE_STRING KeRosVideoBiosVersion
Definition: bug.c:38
KeRosProcessorName
UNICODE_STRING KeRosProcessorName
Definition: bug.c:37
KeRosBiosVersion
UNICODE_STRING KeRosBiosVersion
Definition: bug.c:37
KeRosBiosDate
UNICODE_STRING KeRosBiosDate
Definition: bug.c:37
KeRosVideoBiosDate
UNICODE_STRING KeRosVideoBiosDate
Definition: bug.c:38
CmpInitializeRegistryNode
NTSTATUS NTAPI CmpInitializeRegistryNode(IN PCONFIGURATION_COMPONENT_DATA CurrentEntry, IN HANDLE NodeHandle, OUT PHANDLE NewHandle, IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PUSHORT DeviceIndexTable)
Definition: cmconfig.c:20
CmpConfigurationData
PCM_FULL_RESOURCE_DESCRIPTOR CmpConfigurationData
Definition: cmdata.c:37
CmpConfigurationAreaSize
ULONG CmpConfigurationAreaSize
Definition: cmdata.c:36
TAG_CM
#define TAG_CM
Definition: cmlib.h:212
RtlCreateUnicodeString
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
ObjectAttributes
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
L
#define L(x)
Definition: resources.c:13
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
PAGE_SIZE
#define PAGE_SIZE
Definition: env_spec_w32.h:49
PagedPool
#define PagedPool
Definition: env_spec_w32.h:308
Status
Status
Definition: gdiplustypes.h:25
CmpFullCpuID
PCHAR CmpFullCpuID
Definition: cmhardwr.c:17
CmpGetBiosDate
BOOLEAN NTAPI CmpGetBiosDate(IN PCHAR BiosStart, IN ULONG BiosLength, IN PCHAR BiosDate, IN BOOLEAN FromBios)
Definition: cmhardwr.c:34
CmpGetBiosVersion
BOOLEAN NTAPI CmpGetBiosVersion(IN PCHAR BiosStart, IN ULONG BiosLength, IN PCHAR BiosVersion)
Definition: cmhardwr.c:131
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
REG_SZ
#define REG_SZ
Definition: layer.c:22
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
sprintf
#define sprintf(buf, format,...)
Definition: sprintf.c:55
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
KeyHandle
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
CPU_VIA
@ CPU_VIA
Definition: ketypes.h:101
CPU_AMD
@ CPU_AMD
Definition: ketypes.h:99
Disposition
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
AFFINITY_MASK
FORCEINLINE KAFFINITY AFFINITY_MASK(ULONG Index)
Definition: kefuncs.h:39
ZwOpenSection
NTSYSAPI NTSTATUS NTAPI ZwOpenSection(_Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes)
BaseAddress
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
ViewSize
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
MEM_DOS_LIM
#define MEM_DOS_LIM
Definition: mmtypes.h:90
ZwClose
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NtOpenKey
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
NtSetValueKey
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
REG_BINARY
#define REG_BINARY
Definition: nt_native.h:1496
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1304
KEY_ALL_ACCESS
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
SECTION_ALL_ACCESS
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
KEY_READ
#define KEY_READ
Definition: nt_native.h:1023
RtlAnsiStringToUnicodeString
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1657
REG_OPTION_NON_VOLATILE
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
REG_CREATED_NEW_KEY
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
REG_MULTI_SZ
#define REG_MULTI_SZ
Definition: nt_native.h:1501
ViewUnmap
@ ViewUnmap
Definition: nt_native.h:1279
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
RtlFreeUnicodeString
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
KEY_WRITE
#define KEY_WRITE
Definition: nt_native.h:1031
RtlInitAnsiString
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
NtCreateKey
NTSTATUS NTAPI NtCreateKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG TitleIndex, IN PUNICODE_STRING Class OPTIONAL, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
Definition: ntapi.c:240
PWCH
WCHAR * PWCH
Definition: ntbasedef.h:422
UNICODE_NULL
#define UNICODE_NULL
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
KeI386NpxPresent
ULONG KeI386NpxPresent
Definition: cpu.c:28
KiProcessorBlock
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:31
KeNumberProcessors
CCHAR KeNumberProcessors
Definition: processor.c:19
InterfaceTypeUndefined
@ InterfaceTypeUndefined
Definition: restypes.h:120
REG_DWORD
#define REG_DWORD
Definition: sdbapi.c:596
ProcessorClass
@ ProcessorClass
Definition: arc.h:91
CentralProcessor
@ CentralProcessor
Definition: arc.h:105
MaximumType
@ MaximumType
Definition: arc.h:145
FloatingPointProcessor
@ FloatingPointProcessor
Definition: arc.h:106
strcpy
strcpy
Definition: string.h:131
SharedUserData
#define SharedUserData
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_ANSI_STRING
Definition: env_spec_w32.h:375
_CONFIGURATION_COMPONENT_DATA
Definition: arc.h:164
_CONFIGURATION_COMPONENT_DATA::ComponentEntry
CONFIGURATION_COMPONENT ComponentEntry
Definition: arc.h:168
_CONFIGURATION_COMPONENT::Type
CONFIGURATION_TYPE Type
Definition: arc.h:152
_CONFIGURATION_COMPONENT::Key
ULONG Key
Definition: arc.h:156
_CONFIGURATION_COMPONENT::Identifier
PCHAR Identifier
Definition: arc.h:160
_CONFIGURATION_COMPONENT::IdentifierLength
ULONG IdentifierLength
Definition: arc.h:159
_CONFIGURATION_COMPONENT::AffinityMask
ULONG AffinityMask
Definition: arc.h:157
_CONFIGURATION_COMPONENT::Class
CONFIGURATION_CLASS Class
Definition: arc.h:151
_KPRCB
Definition: ketypes.h:654
_KPRCB::CpuType
CHAR CpuType
Definition: ketypes.h:678
_KPRCB::CpuStep
USHORT CpuStep
Definition: ketypes.h:683
_KPRCB::CpuID
CHAR CpuID
Definition: ketypes.h:679
_KPRCB::CpuVendor
UCHAR CpuVendor
Definition: ketypes.h:698
_KPRCB::VendorString
UCHAR VendorString[13]
Definition: ketypes.h:895
_KPRCB::FeatureBits
ULONG FeatureBits
Definition: ketypes.h:897
_KPRCB::SetMember
UINT64 SetMember
Definition: ketypes.h:676
_KPRCB::UpdateSignature
LARGE_INTEGER UpdateSignature
Definition: ketypes.h:898
_KPRCB::MHz
ULONG MHz
Definition: ketypes.h:693
_OBJECT_ATTRIBUTES
Definition: umtypes.h:182
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
KeSetSystemAffinityThread
VOID NTAPI KeSetSystemAffinityThread(IN KAFFINITY Affinity)
Definition: thrdobj.c:1107
KeRevertToUserAffinityThread
VOID NTAPI KeRevertToUserAffinityThread(VOID)
Definition: thrdobj.c:1021
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_CPU_INFO
Definition: ketypes.h:391
_CPU_INFO::Ebx
ULONG Ebx
Definition: ketypes.h:396
_CPU_INFO::Eax
ULONG Eax
Definition: ketypes.h:395
_CPU_INFO::Ecx
ULONG Ecx
Definition: ketypes.h:397
_CPU_INFO::Edx
ULONG Edx
Definition: ketypes.h:398
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
_LARGE_INTEGER::LowPart
ULONG LowPart
Definition: typedefs.h:106
_LARGE_INTEGER::HighPart
LONG HighPart
Definition: typedefs.h:107
TotalLength
_In_ ULONG TotalLength
Definition: usbdlib.h:158
KeyName
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
ValueName
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
PF_PAE_ENABLED
#define PF_PAE_ENABLED
Definition: ketypes.h:133

Variable Documentation

◆ CmpBiosBegin

PCHAR CmpBiosBegin

Definition at line 28 of file cmhardwr.c.

Referenced by CmpGetBiosVersion().

◆ CmpBiosSearchEnd

PCHAR CmpBiosSearchEnd

Definition at line 28 of file cmhardwr.c.

Referenced by CmpGetBiosVersion().

◆ CmpBiosSearchStart

PCHAR CmpBiosSearchStart

Definition at line 28 of file cmhardwr.c.

Referenced by CmpGetBiosVersion().

◆ CmpBiosStrings

PCHAR CmpBiosStrings[]
Initial value:
=
{
"Ver",
"Rev",
"Rel",
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
"v 0", "v 1", "v 2", "v 3", "v 4", "v 5", "v 6", "v 7", "v 8", "v 9",
NULL
}

Definition at line 18 of file cmhardwr.c.

Referenced by CmpGetBiosVersion().

◆ CmpFullCpuID

PCHAR CmpFullCpuID = "%s Family %u Model %u Stepping %u"

Definition at line 17 of file cmhardwr.c.

Referenced by CmpInitializeMachineDependentConfiguration().