Mehrdeutige CPUID-Ausgaben

[Mok]

Hallo!
Ich habe heute mal wieder das Intel-Handbuch ausgegraben und ein bisschen mit dem CPUID-Befehl herumgespielt. Was ich aber komisch finde ist, dass die Ausgaben, wenn sie von mir programmiert sind, anders sind, als von CPU-Z.
Zum Beispiel:
Family Code:
CPUID gibt in EAX[11:8] die Zahl 15 aus, in CPU-Z steht bei 'Family' allerdings "F" (hä?! ein Buchstabe?)
Extended Model:
CPUID gibt in EAX[19:16] die Zahl 0 aus, in CPU-Z steht bei ExtModel allerdings 3
Extended Family:
CPUID gibt in EAX[27:20] die Zahl 2 aus, in CUP-Z steht bei ExtFamily allerdings 11.
Hier mal ein Code:

Code: Alles auswählen

Define.l cpuid
Define.b model, family, familyex, modelex

!MOV eax, $01
!CPUID
!MOV [v_cpuid], eax

!AND eax, 240
!SAR eax, 4
!MOV [v_model], al
Debug "Model ID:"
Debug model

!MOV eax, [v_cpuid]
!AND eax, 3840
!SAR eax, 8
!MOV [v_family], al
Debug "Family Code:"
Debug family

!MOV eax, [v_cpuid]
!AND eax, 983040
!SAR eax, 16
!MOV [v_modelex], al
Debug "Extended Model:"
Debug modelex

!MOV eax, [v_cpuid]
!AND eax, 267386880
!SAR eax, 20
!MOV [v_familyex], al
Debug "========================="
Debug "Extended Family:"
Debug familyex

Ach ja, so am Rande: Weiß jemand wie ich mittels CPUID die Revision (z.B. "LG-B1") und den Sockel (z.B."M2") auslesen kann?

[ts-soft]

Zum Beispiel:
Family Code:
CPUID gibt in EAX[11:8] die Zahl 15 aus, in CPU-Z steht bei 'Family' allerdings "F" (hä?! ein Buchstabe?)

Code: Alles auswählen

Debug Hex(15)

[Mok]

Vielen Dank, ts-soft
@Topic: Ich gehe einfach mal davon aus, dass die Werte, welche CPU-Z anzeigt fehlerhaft sind, was zwar unwahrscheinlich ist, aber was sonst?

[Helle]

Das CPU-Z fehlerhafte Werte anzeigt halte ich für ein schweres Gerücht ! Probier mal dies aus:

Code: Alles auswählen

;für Intel und AMD, Windows 32/64, Verfügbarkeit von CPUID wird vorausgesetzt

Stepping.l                   ;Bit 0-3
Model.l                      ;Bit 4-7 
Family.l                     ;Bit 8-11
Extended_Model.l             ;Bit 16-19
Extended_Family.l            ;Bit 20-27
IsIntel.i
CPUName.i

CPUName = AllocateMemory(64) ;48 Zeichen + Zero-Bytes (oder nur 49)

CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
  !PUSH ebx  
 CompilerElse  
  !PUSH rbx
CompilerEndIf

!MOV eax,80000000h           ;Test, ob CPU aktuell genug ist um den CPU-Namen-String zu liefern
!CPUID
!CMP eax,80000004h
!JB NoString

CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
  !PUSH edi  
  !PUSH esi 
  !MOV esi,[v_CPUName]
  !XOR edi,edi
!@@:    
  !MOV eax,80000002h
  !ADD eax,edi
  !CPUID        
  !MOV [esi],eax
  !MOV [esi+4],ebx    
  !MOV [esi+8],ecx
  !MOV [esi+12],edx
  !INC edi
  !CMP edi,3
  !JE @f
  !ADD esi,16
  !JMP @b
!@@:
  !POP esi
  !POP edi
 CompilerElse
  !PUSH rdi  
  !PUSH rsi 
  !MOV rsi,[v_CPUName]
  !XOR rdi,rdi
!@@:    
  !MOV eax,80000002h
  !ADD eax,edi
  !CPUID        
  !MOV [rsi],eax
  !MOV [rsi+4],ebx    
  !MOV [rsi+8],ecx
  !MOV [rsi+12],edx
  !INC rdi
  !CMP rdi,3
  !JE @f
  !ADD rsi,16
  !JMP @b
!@@:
  !POP rsi
  !POP rdi
CompilerEndIf

!NoString:

!XOR eax,eax
!CPUID
!CMP ecx,6C65746Eh           ;"l e t n", Teil der Intel-Kennung
!JNE @f
!MOV dword[v_IsIntel],1
!@@:                         ;evtl. Test auf AMD-Kennung

!MOV eax,1
!CPUID

!MOV edx,eax
!AND edx,1111b
!MOV [v_Stepping],edx

!MOV edx,eax
!SHR edx,8
!AND edx,1111b
!MOV [v_Family],edx

!CMP edx,0Fh
!JB @f

!MOV ecx,eax
!SHR ecx,20
!AND ecx,11111111b
!ADD edx,ecx
!@@:
!MOV [v_Extended_Family],edx

!MOV edx,eax
!SHR edx,4
!AND edx,1111b
!MOV [v_Model],edx

!CMP dword[v_Family],0Fh
!JE New_E_M

!CMP dword[v_IsIntel],0
!JE @f

!CMP dword[v_Family],6
!JNE @f

!New_E_M:
!MOV ecx,eax
!SHR ecx,16
!AND ecx,1111b
!SHL ecx,4
!ADD edx,ecx
!@@:
!MOV [v_Extended_Model],edx

CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
  !POP ebx  
 CompilerElse  
  !POP rbx
CompilerEndIf

CPUID$ = "Stepping : $" + Hex(Stepping) + #LFCR$ + "Model : $" + Hex(Model) + #LFCR$ + "Extended Model : $" + Hex(Extended_Model)
CPUID$ + #LFCR$ + "Family : $" + Hex(Family) + #LFCR$ + "Extended Family : $" + Hex(Extended_Family)
MessageRequester("CPUID-Info für " +  LTrim(PeekS(CPUName, -1, #PB_Ascii)), CPUID$)

Gruß
Helle

[Thorium]

Schmeiß mal die AND Operationen raus. Die sehen ziemlich merkwürdig aus und sind sowieso sinnlos, wenn du den Wert ins niederwertigste Byte shiftest und nur AL übergibst.

[Mok]

Ah, vielen Dank, Helle! ;)
Funktioniert super, nur versteh ich nicht ganz was ich falsch gemacht habe^^
(Die Rückmeldung kommt so spät, weil ich kaum Zeit für PB und Co. hatte, aber jetzt sind ja Ferien :)