TITLE CPUID
	DOSSEG
	.model small

	.stack 100h

	.data
fp_status	dw	?
id_mess		db	"This system has a$"
fp_8087		db	" and an 8087 math coprocessor$"
fp_80287	db	" and an i287tm math coprocessor$"
fp_80387	db	" and an i387tm math coprocessor$"
c8086		db	"n 8086/8088 microprocessor$"
c286		db	"n 80286 microprocessor$"
c386		db	" i386tm microprocessor$"
c486		db	" i486tm DX microprocessor or i487tm SX math coprocessor$"
c486nfp		db	" i486tm SX microprocessor$"
period		db	".$",13,10
present_86	dw	0
present_286	dw	0
present_386	dw	0
present_486	dw	0

;
; The purpose of this code is to allow the user the ability to identify the processor and coprocessor
; that is currently in the system. The algorithm of the program is to first determine the processor
; id. When that is accomplished, the program continues to then identify whether a coprocessor
; exists in the system. If a coprocessor or integrated coprocessor exists, the program will identify
; the coprocessor id. If one does not exist, the program then terminates.
;

	.code
start:
	mov	ax, @data
	mov	ds, ax				; set segment register
	
	mov	dx, offset id_mess		; print header message
	mov	ah, 9h
	int	21h

;
; 8086 CPU check
; Bits 12-15 are always set on the 8086 processor.
;

	pushf					; save EFLAGS
	pop	bx				; store EFLAGS in BX
	mov	ax, 0fffh			; clear bits 12-15
	and	ax, bx				; in EFLAGS
	push	ax 				; store new EFLAGS value on stack
	popf					; replace current EFLAGS value
	pushf					; set new EFLAGS
	pop	ax				; store new EFLAGS in AX
	and	ax, 0f000h			; if bits 12-15 are set, then CPU
	cmp	ax, 0f000h			; is an 8086/8088
	mov	dx, offset c8086		; store 8086/8088 message
	mov	present_86, 1			; turn on 8086/8088 flag
	je	check_fpu			; if CPU is 8086/8088, check for 8087

;
; 80286 CPU check
; Bits 12-15 are always clear on the 80286 processor.
;

	or	bx, 0f000h			; try to set bits 12-15
	push	bx
	popf
	pushf
	pop	ax
	and	ax, 0f000h			; if bits 12-15 are cleared, then CPU
	mov	dx, offset c286			; is an 80286
	mov	present_86, 0			; turn off 8086/8088 flag
	mov	present_286, 1			; turn on 80286 flag
	jz	check_fpu			; if CPU is 80286, check for 80287

;
; i386 CPU check
; The AC bit, bit #18, is a new bit introduced in the EFLAGS register on the i486 DX CPU to
; generate alignment faults. This bit can be set on the i486 DX CPU, but not on the i386 CPU.
;

	mov	bx, sp				; save current stack pointer to align it
	and	sp, not 3			; align stack to avoid AC fault
	db	66h
	pushf					; push original EFLAGS
	db	66h
	pop	ax				; get original EFLAGS
	db	66h
	mov	cx, ax				; save original EFLAGS
	db	66h				; xor EAX,40000h
	xor	ax, 0				; flip AC bit in EFLAGS
	dw	4				; upper 16-bits of xor constant
	db	66h
	push	ax				; save for EFLAGS
	db	66h
	popf					; copy to EFLAGS
	db	66h
	pushf					; push EFLAGS
	db	66h
	pop	ax				; get new EFLAGS value
	db	66h
	xor	ax, cx				; if AC bit cannot be changed, CPU is
	mov	dx, offset c386			; store i386 message
	mov	present_286, 0			; turn off 80286 flag
	mov	present_386, 1			; turn on i386 flag
	je	check_fpu			; if CPU is i386, now check for ; 80287/80387 MCP

;
; i486 DX CPU / i487 SX MCP and i486 SX CPU checking
;

	mov	dx, offset c486nfp		; store 486NFP message
	mov	present_386, 0			; turn off i386 flag
	mov	present_486, 1			; turn on i486 flag

;
; Co-processor checking begins here for the 8086/80286/i386 CPUs.
; The algorithm is to determine whether or not the floating-point status and control words can be
; written to. If they are not, no coprocessor exists. If the status and control words can be written
; to, the correct coprocessor is then determined depending on the processor id. Coprocessor
; checks are first performed for an 8086, 80286 and a i486 DX CPU. If the coprocessor id is still
; undetermined, the system must contain a i386 CPU. The i386 CPU may work with either
; an 80287 or an 80387. The infinity of the coprocessor must be checked to determine the correct
; coprocessor id.
;

check_fpu: ; check for 8087/80287/80387
	fninit					; reset FP status word
	mov	fp_status, 5a5ah		; initialize temp word to non-zero value
	fnstsw	fp_status			; save FP status word
	mov	ax, fp_status			; check FP status word
	cmp	al, 0				; see if correct status with written
	jne	print_one			; jump if not Valid, no NPX installed

	fnstcw	fp_status			; save FP control word
	mov	ax, fp_status			; check FP control word
	and	ax, 103fh			; see if selected parts looks OK
	cmp	ax, 3fh				; check that ones and zeroes correctly read
	jne	print_one			; jump if not Valid, no NPX installed

	cmp	present_486, 1			; check if i486 flag is on
	je	is_486				; if so, jump to print 486 message
	jmp	not_486				; else continue with 386 checking

is_486:
	mov	dx, offset c486			; store i486 message
	jmp	print_one

not_486:
	cmp	present_386, 1			; check if i386 flag is on
	jne	print_87_287			; if i386 flag not on, check NPX for
						; 8086/8088/80286
	mov	ah, 9h				; print out i386 CPU ID first
	int	21h

;
; 80287/80387 check for the i386 CPU
;

	fld1					; must use default control from FNINIT
	fldz					; form infinity
	fdiv					; 8087/80287 says +inf = -inf
	fld	st				; form negative infinity
	fchs					; 80387 says +inf <> -inf
	fcompp					; see if they are the same and remove them
	fstsw	fp_status			; look at status from FCOMPP
	mov	ax, fp_status
	mov	dx, offset fp_80287		; store 80287 message
	sahf					; see if infinities matched
	jz	restore_EFLAGS			; jump if 8087/80287 is present
	mov	dx, offset fp_80387		; store 80387 message

restore_EFLAGS:
	mov	ah, 9h				; print NPX message
	int	21h
	db	66h
	push	cx				; push ECX
	db	66h
	popf					; restore original EFLAGS register
	mov	sp, bx				; restore original stack pointer
	jmp	exit

print_one:
	mov	ah, 9h				; print out CPU ID with no NPX
	int	21h
	jmp	exit


print_87_287:
	mov	ah, 9h				; print out 8086/8088/80286 first
	int	21h
	cmp	present_86, 1			; if 8086/8088 flag is on
	mov	dx, offset fp_8087		; store 8087 message
	je	print_fpu
	mov	dx, offset fp_80287		; else CPU=80286, store 80287 message

print_fpu:
	mov	ah, 9h				; print out NPX
	int	21h
	jmp	exit

exit:
	mov	dx, offset period		; print out a period to end message
	mov	ah, 9h
	int	21h
	
	mov	ax, 4c00h			; terminate program
	int	21h

end	start