WebSVN – Kolibri OS – Diff – /drivers/video/vidintel.asm


; Stub of videodriver for Intel videocards.
; (c) CleverMouse
 
; When the start procedure gots control,
; it tries to detect preferred resolution,
; sets the detected resolution assuming 32-bpp VESA mode and exits
; (without registering a service).
; Detection can be overloaded with compile-time settings
; use_predefined_mode/predefined_width/predefined_height.
 
; set predefined resolution here
use_predefined_mode = 0;1
predefined_width = 0;1366
predefined_height = 0;768
 
; standard driver stuff; target OS version = 0.80
format PE DLL native 0.80
entry START
__DEBUG__ equ 1
__DEBUG_LEVEL__ equ 1
section '.flat' readable writable executable
include '../proc32.inc'
include '../struct.inc'
include '../macros.inc'
;include 'fdo.inc'
 
DEBUG = 1
 
 
 
 
 
 
 
 
; the start procedure (see the description above)
START:
; 1. Detect device. Abort if not found.
        push    esi
        call    DetectDevice
        test    esi, esi
        jz      .return0
; 2. Detect optimal mode unless the mode is given explicitly. Abort if failed.
if use_predefined_mode = 0
        call    DetectMode
end if
        cmp     [width], 0
        jz      .return0_cleanup
; 3. Set the detected mode.
        call    SetMode
; 4. Cleanup and return.
.return0_cleanup:
        invoke  FreeKernelSpace, esi
.return0:
        pop     esi
        xor     eax, eax
        ret
 
; check that there is Intel videocard
; if so, map MMIO registers and set internal variables
; esi points to MMIO block; NULL means no device
DetectDevice:
; 1. Sanity check: check that we are dealing with Intel videocard.
; Integrated video device for Intel is always at PCI:0:2:0.
        xor     esi, esi        ; initialize return value to NULL
; 1a. Get PCI VendorID and DeviceID.
        push    esi
        push    10h
        push    esi
        invoke  PciRead32
; 1b. loword(eax) = ax = VendorID, hiword(eax) = DeviceID.
; Test whether we have Intel chipset.
        cmp     ax, 8086h
        jnz     .return
; 1c. Say hi including DeviceID.
        shr     eax, 10h
        push    edi
        pusha
        mov     edi, pciid_text
        call    WriteWord
        mov     esi, hellomsg
        invoke  SysMsgBoardStr
        popa
; 1d. Test whether we know this DeviceID.
; If this is the case, remember the position of the device in line of Intel cards;
; this knowledge will be useful later.
; Tested on devices with id: 8086:0046, partially 8086:2A02.
        mov     ecx, pciids_num
        mov     edi, pciids
        repnz scasw
        pop     edi
        jnz     .return_unknown_pciid
        sub     ecx, pciids_num - 1
        neg     ecx
        mov     [deviceType], ecx
; 1e. Continue saying hi with positive intonation.
        pusha
        mov     esi, knownmsg
        invoke  SysMsgBoardStr
        popa
; 2. Prepare MMIO region to control the card.
; 2a. Read MMIO physical address from PCI config space.
        push    10h
        cmp     ecx, i9xx_start
        jae     @f
        mov     byte [esp], 14h
@@:
        push    10h
        push    esi
        invoke  PciRead32
; 2b. Mask out PCI region type, lower 4 bits.
        and     al, not 0xF
; 2c. Create virtual mapping of the physical memory.
        push    1Bh
        push    100000h
        push    eax
        invoke  MapIoMem
; 3. Return.
        xchg    esi, eax
.return:
        ret
; 1f. If we do not know DeviceID, continue saying hi with negative intonation.
.return_unknown_pciid:
        pusha
        mov     esi, unknownmsg
        invoke  SysMsgBoardStr
        popa
        ret
 
; Convert word in ax to hexadecimal text in edi, advance edi.
WriteWord:
; 1. Convert high byte.
        push    eax
        mov     al, ah
        call    WriteByte
        pop     eax
; 2. Convert low byte.
; Fall through to WriteByte; ret from WriteByte is ret from WriteWord too.
 
; Convert byte in al to hexadecimal text in edi, advance edi.
WriteByte:
; 1. Convert high nibble.
        push    eax
        shr     al, 4
        call    WriteNibble
        pop     eax
; 2. Convert low nibble.
        and     al, 0xF
; Fall through to WriteNibble; ret from WriteNibble is ret from WriteByte too.
 
; Convert nibble in al to hexadecimal text in edi, advance edi.
WriteNibble:
; Obvious, isn't it?
        cmp     al, 10
        sbb     al, 69h
        das
        stosb
        ret
 
if use_predefined_mode = 0
; detect resolution of the flat panel
DetectMode:
        push    esi edi
; 1. Get the location of block of GMBUS* registers.
; Starting with Ironlake, GMBUS* registers were moved.
        add     esi, 5100h
        cmp     [deviceType], ironlake_start
        jb      @f
        add     esi, 0xC0000
@@:
; 2. Initialize GMBUS engine.
        mov     edi, edid
        mov     ecx, 0x10000
@@:
        test    byte [esi+8+1], 80h
        loopnz  @b
        jnz     .fail
        mov     dword [esi], 3
        test    byte [esi+8+1], 4
        jz      .noreset
        call    ResetGMBus
        jnz     .fail
.noreset:
; 3. Send read command.
        and     dword [esi+20h], 0
        mov     dword [esi+4], 4E8000A1h
; 4. Wait for data, writing to the buffer as data arrive.
.getdata:
        mov     ecx, 0x10000
@@:
        test    byte [esi+8+1], 8
        loopz   @b
        test    byte [esi+8+1], 4
        jz      .dataok
        call    ResetGMBus
        jmp     .fail
.dataok:
        mov     eax, [esi+0Ch]
        stosd
        cmp     edi, edid+80h
        jb      .getdata
; 5. Wait for bus idle.
        mov     ecx, 0x10000
@@:
        test    byte [esi+8+1], 2
        loopnz  @b
; 6. We got EDID; dump it if DEBUG.
if DEBUG
        pusha
        xor     ecx, ecx
        mov     esi, edid
        mov     edi, edid_text
.dumploop:
        lodsb
        call    WriteByte
        mov     al, ' '
        stosb
        inc     cl
        test    cl, 15
        jnz     @f
        mov     byte [edi-1], 13
        mov     al, 10
        stosb
@@:
        test    cl, cl
        jns     .dumploop
        mov     esi, edidmsg
        invoke  SysMsgBoardStr
        popa
end if
; 7. Test whether EDID is good.
; 7a. Signature: 00 FF FF FF FF FF FF 00.
        mov     esi, edid
        cmp     dword [esi], 0xFFFFFF00
        jnz     .fail
        cmp     dword [esi+4], 0x00FFFFFF
        jnz     .fail
; 7b. Checksum must be zero.
        xor     edx, edx
        mov     ecx, 80h
@@:
        lodsb
        add     dl, al
        loop    @b
        jnz     .fail
; 8. Get width and height from EDID.
        xor     eax, eax
        mov     ah, [esi-80h+3Ah]
        shr     ah, 4
        mov     al, [esi-80h+38h]
        mov     [width], eax
        mov     ah, [esi-80h+3Dh]
        shr     ah, 4
        mov     al, [esi-80h+3Bh]
        mov     [height], eax
; 9. Return.
.fail:
        pop     edi esi
        ret
 
; reset bus, clear all errors
ResetGMBus:
; look into the PRM
        mov     dword [esi+4], 80000000h
        mov     dword [esi+4], 0
        mov     ecx, 0x10000
@@:
        test    byte [esi+8+1], 2
        loopnz  @b
        ret
end if
 
; set resolution [width]*[height]
SetMode:
; 1. Program the registers of videocard.
; look into the PRM
        cli
;       or      byte [esi+7000Ah], 0Ch  ; PIPEACONF: disable Display+Cursor Planes
;       or      byte [esi+7100Ah], 0Ch  ; PIPEBCONF: disable Display+Cursor Planes
        xor     eax, eax
        xor     edx, edx
        cmp     [deviceType], i965_start
        jb      @f
        mov     dl, 9Ch - 84h
@@:
;       or      byte [esi+71403h], 80h  ; VGACNTRL: VGA Display Disable
        and     byte [esi+70080h], not 27h      ; CURACNTR: disable cursor A
        mov     dword [esi+70084h], eax ; CURABASE: force write to CURA* regs
        and     byte [esi+700C0h], not 27h      ; CURBCNTR: disable cursor B
        mov     dword [esi+700C4h], eax ; CURBBASE: force write to CURB* regs
        and     byte [esi+70183h], not 80h      ; DSPACNTR: disable Primary A Plane
        mov     dword [esi+edx+70184h], eax     ; DSPALINOFF/DSPASURF: force write to DSPA* regs
        and     byte [esi+71183h], not 80h      ; DSPBCNTR: disable Primary B Plane
        mov     dword [esi+edx+71184h], eax     ; DSPBLINOFF/DSPBSURF: force write to DSPB* regs
if 1
        cmp     [deviceType], ironlake_start
        jae     .disable_pipes
        mov     edx, 10000h
        or      byte [esi+70024h], 2    ; PIPEASTAT: clear VBLANK status
        or      byte [esi+71024h], 2    ; PIPEBSTAT: clear VBLANK status
.wait_vblank_preironlake1:
        mov     ecx, 1000h
        loop    $
        test    byte [esi+7000Bh], 80h          ; PIPEACONF: pipe A active?
        jz      @f
        test    byte [esi+70024h], 2            ; PIPEASTAT: got VBLANK?
        jz      .wait_vblank_preironlake2
@@:
        test    byte [esi+7100Bh], 80h          ; PIPEBCONF: pipe B active?
        jz      .disable_pipes
        test    byte [esi+71024h], 2            ; PIPEBSTAT: got VBLANK?
        jnz     .disable_pipes
.wait_vblank_preironlake2:
        dec     edx
        jnz     .wait_vblank_preironlake1
        jmp     .not_disabled
.disable_pipes:
end if
        and     byte [esi+7000Bh], not 80h      ; PIPEACONF: disable pipe
        and     byte [esi+7100Bh], not 80h      ; PIPEBCONF: disable pipe
        cmp     [deviceType], gen4_start
        jb      .wait_watching_scanline
; g45 and later: use special flag from PIPE*CONF
        mov     edx, 10000h
@@:
        mov     ecx, 1000h
        loop    $
        test    byte [esi+7000Bh], 40h  ; PIPEACONF: wait until pipe disabled
        jz      @f
        dec     edx
        jnz     @b
        jmp     .not_disabled
@@:
        test    byte [esi+7100Bh], 40h  ; PIPEBCONF: wait until pipe disabled
        jz      .disabled
        mov     ecx, 1000h
        loop    $
        dec     edx
        jnz     @b
        jmp     .not_disabled
; pineview and before: wait while scanline still changes
.wait_watching_scanline:
        mov     edx, 1000h
.dis1:
        push    dword [esi+71000h]
        push    dword [esi+70000h]
        mov     ecx, 10000h
        loop    $
        pop     eax
        xor     eax, [esi+70000h]
        and     eax, 1FFFh
        pop     eax
        jnz     .notdis1
        xor     eax, [esi+71000h]
        and     eax, 1FFFh
        jz      .disabled
.notdis1:
        dec     edx
        jnz     .dis1
.not_disabled:
        sti
        jmp     .return
.disabled:
        lea     eax, [esi+61183h]
        cmp     [deviceType], ironlake_start
        jb      @f
        add     eax, 0xE0000 - 0x60000
@@:
        lea     edx, [esi+60000h]
        test    byte [eax], 40h
        jz      @f
        add     edx, 1000h
@@:
        mov     eax, [width]
        dec     eax
        shl     eax, 16
        mov     ax, word [height]
        dec     eax
        mov     dword [edx+1Ch], eax    ; PIPEASRC: set source image size
        ror     eax, 16
        mov     dword [edx+10190h], eax ; for old cards
        mov     ecx, [width]
        add     ecx, 15
        and     ecx, not 15
        shl     ecx, 2
        mov     dword [edx+10188h], ecx ; DSPASTRIDE: set scanline length
        mov     dword [edx+10184h], 0   ; DSPALINOFF: force write to DSPA* registers
        and     byte [esi+61233h], not 80h      ; PFIT_CONTROL: disable panel fitting 
        or      byte [edx+1000Bh], 80h          ; PIPEACONF: enable pipe
;       and     byte [edx+1000Ah], not 0Ch      ; PIPEACONF: enable Display+Cursor Planes
        or      byte [edx+10183h], 80h          ; DSPACNTR: enable Display Plane A
        sti
; 2. Notify the kernel that resolution has changed.
        invoke  GetDisplay
        mov     edx, [width]
        mov     dword [eax+8], edx
        mov     edx, [height]
        mov     dword [eax+0Ch], edx
        mov     [eax+18h], ecx
        mov     eax, [width]
        dec     eax
        dec     edx
        invoke  SetScreen
.return:
        ret
 
include '../peimport.inc'
data fixups
end data
 
align 4
hellomsg        db      'Intel videocard detected, PciId=8086:'
pciid_text      db      '0000'
                db      ', which is ', 0
knownmsg        db      'known',13,10,0
unknownmsg      db      'unknown',13,10,0
 
if DEBUG
edidmsg         db      'EDID successfully read:',13,10
edid_text       rb      8*(16*3+1)
                db      0
end if
 
 
 
 
width   dd      predefined_width
height  dd      predefined_height
 
pciids:
        dw      0x3577          ; i830m
        dw      0x2562          ; 845g
        dw      0x3582          ; i855gm
i865_start = ($ - pciids) / 2
        dw      0x2572          ; i865g
i9xx_start = ($ - pciids) / 2
        dw      0x2582  ; i915g
        dw      0x258a  ; e7221g (i915g)
        dw      0x2592  ; i915gm
        dw      0x2772  ; i945g
        dw      0x27a2  ; i945gm
        dw      0x27ae  ; i945gme
i965_start = ($ - pciids) / 2
        dw      0x2972  ; i946qz (i965g)
        dw      0x2982  ; g35g (i965g)
        dw      0x2992  ; i965q (i965g)
        dw      0x29a2  ; i965g
        dw      0x29b2  ; q35g
        dw      0x29c2  ; g33g
        dw      0x29d2  ; q33g
        dw      0xa001  ; pineview
        dw      0xa011  ; pineview
gen4_start = ($ - pciids) / 2
        dw      0x2a02  ; i965gm
        dw      0x2a12  ; i965gm
        dw      0x2a42  ; gm45
        dw      0x2e02  ; g45
        dw      0x2e12  ; g45
        dw      0x2e22  ; g45
        dw      0x2e32  ; g45
        dw      0x2e42  ; g45
        dw      0x2e92  ; g45
ironlake_start = ($ - pciids) / 2
        dw      0x0042  ; ironlake_d
        dw      0x0046  ; ironlake_m
        dw      0x0102  ; sandybridge_d
        dw      0x0112  ; sandybridge_d
        dw      0x0122  ; sandybridge_d
        dw      0x0106  ; sandybridge_m
        dw      0x0116  ; sandybridge_m
        dw      0x0126  ; sandybridge_m
        dw      0x010A  ; sandybridge_d
pciids_num = ($ - pciids) / 2
 
align 4
deviceType      dd      ?
edid    rb      0x80

Rev 3708	Rev 5039
1	; Stub of videodriver for Intel videocards.	1	; Stub of videodriver for Intel videocards.
2	; (c) CleverMouse	2	; (c) CleverMouse
3		3
4	; When the start procedure gots control,	4	; When the start procedure gots control,
5	; it tries to detect preferred resolution,	5	; it tries to detect preferred resolution,
6	; sets the detected resolution assuming 32-bpp VESA mode and exits	6	; sets the detected resolution assuming 32-bpp VESA mode and exits
7	; (without registering a service).	7	; (without registering a service).
8	; Detection can be overloaded with compile-time settings	8	; Detection can be overloaded with compile-time settings
9	; use_predefined_mode/predefined_width/predefined_height.	9	; use_predefined_mode/predefined_width/predefined_height.
10		10
11	; set predefined resolution here	11	; set predefined resolution here
12	use_predefined_mode = 0;1	12	use_predefined_mode = 0;1
13	predefined_width = 0;1366	13	predefined_width = 0;1366
14	predefined_height = 0;768	14	predefined_height = 0;768
15		15
16	; standard driver stuff	16	; standard driver stuff; target OS version = 0.80
-		17	format PE DLL native 0.80
-		18	entry START
-		19	__DEBUG__ equ 1
-		20	__DEBUG_LEVEL__ equ 1
-		21	section '.flat' readable writable executable
-		22	include '../proc32.inc'
-		23	include '../struct.inc'
-		24	include '../macros.inc'
17	format MS COFF	25	;include 'fdo.inc'
18		26
19	DEBUG = 1	27	DEBUG = 1
20		-
21	include 'proc32.inc'	-
22	include 'imports.inc'	-
23		-
24	public START	-
25	public version	-
26		-
27	section '.flat' code readable align 16	28
28	; the start procedure (see the description above)	29	; the start procedure (see the description above)
29	START:	30	START:
30	; 1. Detect device. Abort if not found.	31	; 1. Detect device. Abort if not found.
31	push esi	32	push esi
32	call DetectDevice	33	call DetectDevice
33	test esi, esi	34	test esi, esi
34	jz .return0	35	jz .return0
35	; 2. Detect optimal mode unless the mode is given explicitly. Abort if failed.	36	; 2. Detect optimal mode unless the mode is given explicitly. Abort if failed.
36	if use_predefined_mode = 0	37	if use_predefined_mode = 0
37	call DetectMode	38	call DetectMode
38	end if	39	end if
39	cmp [width], 0	40	cmp [width], 0
40	jz .return0_cleanup	41	jz .return0_cleanup
41	; 3. Set the detected mode.	42	; 3. Set the detected mode.
42	call SetMode	43	call SetMode
43	; 4. Cleanup and return.	44	; 4. Cleanup and return.
44	.return0_cleanup:	45	.return0_cleanup:
45	stdcall FreeKernelSpace, esi	46	invoke FreeKernelSpace, esi
46	.return0:	47	.return0:
47	pop esi	48	pop esi
48	xor eax, eax	49	xor eax, eax
49	ret 4	50	ret
50		51
51	; check that there is Intel videocard	52	; check that there is Intel videocard
52	; if so, map MMIO registers and set internal variables	53	; if so, map MMIO registers and set internal variables
53	; esi points to MMIO block; NULL means no device	54	; esi points to MMIO block; NULL means no device
54	DetectDevice:	55	DetectDevice:
55	; 1. Sanity check: check that we are dealing with Intel videocard.	56	; 1. Sanity check: check that we are dealing with Intel videocard.
56	; Integrated video device for Intel is always at PCI:0:2:0.	57	; Integrated video device for Intel is always at PCI:0:2:0.
57	xor esi, esi ; initialize return value to NULL	58	xor esi, esi ; initialize return value to NULL
58	; 1a. Get PCI VendorID and DeviceID.	59	; 1a. Get PCI VendorID and DeviceID.
59	push esi	60	push esi
60	push 10h	61	push 10h
61	push esi	62	push esi
62	call PciRead32	63	invoke PciRead32
63	; 1b. loword(eax) = ax = VendorID, hiword(eax) = DeviceID.	64	; 1b. loword(eax) = ax = VendorID, hiword(eax) = DeviceID.
64	; Test whether we have Intel chipset.	65	; Test whether we have Intel chipset.
65	cmp ax, 8086h	66	cmp ax, 8086h
66	jnz .return	67	jnz .return
67	; 1c. Say hi including DeviceID.	68	; 1c. Say hi including DeviceID.
68	shr eax, 10h	69	shr eax, 10h
69	push edi	70	push edi
70	pusha	71	pusha
71	mov edi, pciid_text	72	mov edi, pciid_text
72	call WriteWord	73	call WriteWord
73	mov esi, hellomsg	74	mov esi, hellomsg
74	call SysMsgBoardStr	75	invoke SysMsgBoardStr
75	popa	76	popa
76	; 1d. Test whether we know this DeviceID.	77	; 1d. Test whether we know this DeviceID.
77	; If this is the case, remember the position of the device in line of Intel cards;	78	; If this is the case, remember the position of the device in line of Intel cards;
78	; this knowledge will be useful later.	79	; this knowledge will be useful later.
79	; Tested on devices with id: 8086:0046, partially 8086:2A02.	80	; Tested on devices with id: 8086:0046, partially 8086:2A02.
80	mov ecx, pciids_num	81	mov ecx, pciids_num
81	mov edi, pciids	82	mov edi, pciids
82	repnz scasw	83	repnz scasw
83	pop edi	84	pop edi
84	jnz .return_unknown_pciid	85	jnz .return_unknown_pciid
85	sub ecx, pciids_num - 1	86	sub ecx, pciids_num - 1
86	neg ecx	87	neg ecx
87	mov [deviceType], ecx	88	mov [deviceType], ecx
88	; 1e. Continue saying hi with positive intonation.	89	; 1e. Continue saying hi with positive intonation.
89	pusha	90	pusha
90	mov esi, knownmsg	91	mov esi, knownmsg
91	call SysMsgBoardStr	92	invoke SysMsgBoardStr
92	popa	93	popa
93	; 2. Prepare MMIO region to control the card.	94	; 2. Prepare MMIO region to control the card.
94	; 2a. Read MMIO physical address from PCI config space.	95	; 2a. Read MMIO physical address from PCI config space.
95	push 10h	96	push 10h
96	cmp ecx, i9xx_start	97	cmp ecx, i9xx_start
97	jae @f	98	jae @f
98	mov byte [esp], 14h	99	mov byte [esp], 14h
99	@@:	100	@@:
100	push 10h	101	push 10h
101	push esi	102	push esi
102	call PciRead32	103	invoke PciRead32
103	; 2b. Mask out PCI region type, lower 4 bits.	104	; 2b. Mask out PCI region type, lower 4 bits.
104	and al, not 0xF	105	and al, not 0xF
105	; 2c. Create virtual mapping of the physical memory.	106	; 2c. Create virtual mapping of the physical memory.
106	push 1Bh	107	push 1Bh
107	push 100000h	108	push 100000h
108	push eax	109	push eax
109	call MapIoMem	110	invoke MapIoMem
110	; 3. Return.	111	; 3. Return.
111	xchg esi, eax	112	xchg esi, eax
112	.return:	113	.return:
113	ret	114	ret
114	; 1f. If we do not know DeviceID, continue saying hi with negative intonation.	115	; 1f. If we do not know DeviceID, continue saying hi with negative intonation.
115	.return_unknown_pciid:	116	.return_unknown_pciid:
116	pusha	117	pusha
117	mov esi, unknownmsg	118	mov esi, unknownmsg
118	call SysMsgBoardStr	119	invoke SysMsgBoardStr
119	popa	120	popa
120	ret	121	ret
121		122
122	; Convert word in ax to hexadecimal text in edi, advance edi.	123	; Convert word in ax to hexadecimal text in edi, advance edi.
123	WriteWord:	124	WriteWord:
124	; 1. Convert high byte.	125	; 1. Convert high byte.
125	push eax	126	push eax
126	mov al, ah	127	mov al, ah
127	call WriteByte	128	call WriteByte
128	pop eax	129	pop eax
129	; 2. Convert low byte.	130	; 2. Convert low byte.
130	; Fall through to WriteByte; ret from WriteByte is ret from WriteWord too.	131	; Fall through to WriteByte; ret from WriteByte is ret from WriteWord too.
131		132
132	; Convert byte in al to hexadecimal text in edi, advance edi.	133	; Convert byte in al to hexadecimal text in edi, advance edi.
133	WriteByte:	134	WriteByte:
134	; 1. Convert high nibble.	135	; 1. Convert high nibble.
135	push eax	136	push eax
136	shr al, 4	137	shr al, 4
137	call WriteNibble	138	call WriteNibble
138	pop eax	139	pop eax
139	; 2. Convert low nibble.	140	; 2. Convert low nibble.
140	and al, 0xF	141	and al, 0xF
141	; Fall through to WriteNibble; ret from WriteNibble is ret from WriteByte too.	142	; Fall through to WriteNibble; ret from WriteNibble is ret from WriteByte too.
142		143
143	; Convert nibble in al to hexadecimal text in edi, advance edi.	144	; Convert nibble in al to hexadecimal text in edi, advance edi.
144	WriteNibble:	145	WriteNibble:
145	; Obvious, isn't it?	146	; Obvious, isn't it?
146	cmp al, 10	147	cmp al, 10
147	sbb al, 69h	148	sbb al, 69h
148	das	149	das
149	stosb	150	stosb
150	ret	151	ret
151		152
152	if use_predefined_mode = 0	153	if use_predefined_mode = 0
153	; detect resolution of the flat panel	154	; detect resolution of the flat panel
154	DetectMode:	155	DetectMode:
155	push esi edi	156	push esi edi
156	; 1. Get the location of block of GMBUS* registers.	157	; 1. Get the location of block of GMBUS* registers.
157	; Starting with Ironlake, GMBUS* registers were moved.	158	; Starting with Ironlake, GMBUS* registers were moved.
158	add esi, 5100h	159	add esi, 5100h
159	cmp [deviceType], ironlake_start	160	cmp [deviceType], ironlake_start
160	jb @f	161	jb @f
161	add esi, 0xC0000	162	add esi, 0xC0000
162	@@:	163	@@:
163	; 2. Initialize GMBUS engine.	164	; 2. Initialize GMBUS engine.
164	mov edi, edid	165	mov edi, edid
165	mov ecx, 0x10000	166	mov ecx, 0x10000
166	@@:	167	@@:
167	test byte [esi+8+1], 80h	168	test byte [esi+8+1], 80h
168	loopnz @b	169	loopnz @b
169	jnz .fail	170	jnz .fail
170	mov dword [esi], 3	171	mov dword [esi], 3
171	test byte [esi+8+1], 4	172	test byte [esi+8+1], 4
172	jz .noreset	173	jz .noreset
173	call ResetGMBus	174	call ResetGMBus
174	jnz .fail	175	jnz .fail
175	.noreset:	176	.noreset:
176	; 3. Send read command.	177	; 3. Send read command.
177	and dword [esi+20h], 0	178	and dword [esi+20h], 0
178	mov dword [esi+4], 4E8000A1h	179	mov dword [esi+4], 4E8000A1h
179	; 4. Wait for data, writing to the buffer as data arrive.	180	; 4. Wait for data, writing to the buffer as data arrive.
180	.getdata:	181	.getdata:
181	mov ecx, 0x10000	182	mov ecx, 0x10000
182	@@:	183	@@:
183	test byte [esi+8+1], 8	184	test byte [esi+8+1], 8
184	loopz @b	185	loopz @b
185	test byte [esi+8+1], 4	186	test byte [esi+8+1], 4
186	jz .dataok	187	jz .dataok
187	call ResetGMBus	188	call ResetGMBus
188	jmp .fail	189	jmp .fail
189	.dataok:	190	.dataok:
190	mov eax, [esi+0Ch]	191	mov eax, [esi+0Ch]
191	stosd	192	stosd
192	cmp edi, edid+80h	193	cmp edi, edid+80h
193	jb .getdata	194	jb .getdata
194	; 5. Wait for bus idle.	195	; 5. Wait for bus idle.
195	mov ecx, 0x10000	196	mov ecx, 0x10000
196	@@:	197	@@:
197	test byte [esi+8+1], 2	198	test byte [esi+8+1], 2
198	loopnz @b	199	loopnz @b
199	; 6. We got EDID; dump it if DEBUG.	200	; 6. We got EDID; dump it if DEBUG.
200	if DEBUG	201	if DEBUG
201	pusha	202	pusha
202	xor ecx, ecx	203	xor ecx, ecx
203	mov esi, edid	204	mov esi, edid
204	mov edi, edid_text	205	mov edi, edid_text
205	.dumploop:	206	.dumploop:
206	lodsb	207	lodsb
207	call WriteByte	208	call WriteByte
208	mov al, ' '	209	mov al, ' '
209	stosb	210	stosb
210	inc cl	211	inc cl
211	test cl, 15	212	test cl, 15
212	jnz @f	213	jnz @f
213	mov byte [edi-1], 13	214	mov byte [edi-1], 13
214	mov al, 10	215	mov al, 10
215	stosb	216	stosb
216	@@:	217	@@:
217	test cl, cl	218	test cl, cl
218	jns .dumploop	219	jns .dumploop
219	mov esi, edidmsg	220	mov esi, edidmsg
220	call SysMsgBoardStr	221	invoke SysMsgBoardStr
221	popa	222	popa
222	end if	223	end if
223	; 7. Test whether EDID is good.	224	; 7. Test whether EDID is good.
224	; 7a. Signature: 00 FF FF FF FF FF FF 00.	225	; 7a. Signature: 00 FF FF FF FF FF FF 00.
225	mov esi, edid	226	mov esi, edid
226	cmp dword [esi], 0xFFFFFF00	227	cmp dword [esi], 0xFFFFFF00
227	jnz .fail	228	jnz .fail
228	cmp dword [esi+4], 0x00FFFFFF	229	cmp dword [esi+4], 0x00FFFFFF
229	jnz .fail	230	jnz .fail
230	; 7b. Checksum must be zero.	231	; 7b. Checksum must be zero.
231	xor edx, edx	232	xor edx, edx
232	mov ecx, 80h	233	mov ecx, 80h
233	@@:	234	@@:
234	lodsb	235	lodsb
235	add dl, al	236	add dl, al
236	loop @b	237	loop @b
237	jnz .fail	238	jnz .fail
238	; 8. Get width and height from EDID.	239	; 8. Get width and height from EDID.
239	xor eax, eax	240	xor eax, eax
240	mov ah, [esi-80h+3Ah]	241	mov ah, [esi-80h+3Ah]
241	shr ah, 4	242	shr ah, 4
242	mov al, [esi-80h+38h]	243	mov al, [esi-80h+38h]
243	mov [width], eax	244	mov [width], eax
244	mov ah, [esi-80h+3Dh]	245	mov ah, [esi-80h+3Dh]
245	shr ah, 4	246	shr ah, 4
246	mov al, [esi-80h+3Bh]	247	mov al, [esi-80h+3Bh]
247	mov [height], eax	248	mov [height], eax
248	; 9. Return.	249	; 9. Return.
249	.fail:	250	.fail:
250	pop edi esi	251	pop edi esi
251	ret	252	ret
252		253
253	; reset bus, clear all errors	254	; reset bus, clear all errors
254	ResetGMBus:	255	ResetGMBus:
255	; look into the PRM	256	; look into the PRM
256	mov dword [esi+4], 80000000h	257	mov dword [esi+4], 80000000h
257	mov dword [esi+4], 0	258	mov dword [esi+4], 0
258	mov ecx, 0x10000	259	mov ecx, 0x10000
259	@@:	260	@@:
260	test byte [esi+8+1], 2	261	test byte [esi+8+1], 2
261	loopnz @b	262	loopnz @b
262	ret	263	ret
263	end if	264	end if
264		265
265	; set resolution [width]*[height]	266	; set resolution [width]*[height]
266	SetMode:	267	SetMode:
267	; 1. Program the registers of videocard.	268	; 1. Program the registers of videocard.
268	; look into the PRM	269	; look into the PRM
269	cli	270	cli
270	; or byte [esi+7000Ah], 0Ch ; PIPEACONF: disable Display+Cursor Planes	271	; or byte [esi+7000Ah], 0Ch ; PIPEACONF: disable Display+Cursor Planes
271	; or byte [esi+7100Ah], 0Ch ; PIPEBCONF: disable Display+Cursor Planes	272	; or byte [esi+7100Ah], 0Ch ; PIPEBCONF: disable Display+Cursor Planes
272	xor eax, eax	273	xor eax, eax
273	xor edx, edx	274	xor edx, edx
274	cmp [deviceType], i965_start	275	cmp [deviceType], i965_start
275	jb @f	276	jb @f
276	mov dl, 9Ch - 84h	277	mov dl, 9Ch - 84h
277	@@:	278	@@:
278	; or byte [esi+71403h], 80h ; VGACNTRL: VGA Display Disable	279	; or byte [esi+71403h], 80h ; VGACNTRL: VGA Display Disable
279	and byte [esi+70080h], not 27h ; CURACNTR: disable cursor A	280	and byte [esi+70080h], not 27h ; CURACNTR: disable cursor A
280	mov dword [esi+70084h], eax ; CURABASE: force write to CURA* regs	281	mov dword [esi+70084h], eax ; CURABASE: force write to CURA* regs
281	and byte [esi+700C0h], not 27h ; CURBCNTR: disable cursor B	282	and byte [esi+700C0h], not 27h ; CURBCNTR: disable cursor B
282	mov dword [esi+700C4h], eax ; CURBBASE: force write to CURB* regs	283	mov dword [esi+700C4h], eax ; CURBBASE: force write to CURB* regs
283	and byte [esi+70183h], not 80h ; DSPACNTR: disable Primary A Plane	284	and byte [esi+70183h], not 80h ; DSPACNTR: disable Primary A Plane
284	mov dword [esi+edx+70184h], eax ; DSPALINOFF/DSPASURF: force write to DSPA* regs	285	mov dword [esi+edx+70184h], eax ; DSPALINOFF/DSPASURF: force write to DSPA* regs
285	and byte [esi+71183h], not 80h ; DSPBCNTR: disable Primary B Plane	286	and byte [esi+71183h], not 80h ; DSPBCNTR: disable Primary B Plane
286	mov dword [esi+edx+71184h], eax ; DSPBLINOFF/DSPBSURF: force write to DSPB* regs	287	mov dword [esi+edx+71184h], eax ; DSPBLINOFF/DSPBSURF: force write to DSPB* regs
287	if 1	288	if 1
288	cmp [deviceType], ironlake_start	289	cmp [deviceType], ironlake_start
289	jae .disable_pipes	290	jae .disable_pipes
290	mov edx, 10000h	291	mov edx, 10000h
291	or byte [esi+70024h], 2 ; PIPEASTAT: clear VBLANK status	292	or byte [esi+70024h], 2 ; PIPEASTAT: clear VBLANK status
292	or byte [esi+71024h], 2 ; PIPEBSTAT: clear VBLANK status	293	or byte [esi+71024h], 2 ; PIPEBSTAT: clear VBLANK status
293	.wait_vblank_preironlake1:	294	.wait_vblank_preironlake1:
294	mov ecx, 1000h	295	mov ecx, 1000h
295	loop $	296	loop $
296	test byte [esi+7000Bh], 80h ; PIPEACONF: pipe A active?	297	test byte [esi+7000Bh], 80h ; PIPEACONF: pipe A active?
297	jz @f	298	jz @f
298	test byte [esi+70024h], 2 ; PIPEASTAT: got VBLANK?	299	test byte [esi+70024h], 2 ; PIPEASTAT: got VBLANK?
299	jz .wait_vblank_preironlake2	300	jz .wait_vblank_preironlake2
300	@@:	301	@@:
301	test byte [esi+7100Bh], 80h ; PIPEBCONF: pipe B active?	302	test byte [esi+7100Bh], 80h ; PIPEBCONF: pipe B active?
302	jz .disable_pipes	303	jz .disable_pipes
303	test byte [esi+71024h], 2 ; PIPEBSTAT: got VBLANK?	304	test byte [esi+71024h], 2 ; PIPEBSTAT: got VBLANK?
304	jnz .disable_pipes	305	jnz .disable_pipes
305	.wait_vblank_preironlake2:	306	.wait_vblank_preironlake2:
306	dec edx	307	dec edx
307	jnz .wait_vblank_preironlake1	308	jnz .wait_vblank_preironlake1
308	jmp .not_disabled	309	jmp .not_disabled
309	.disable_pipes:	310	.disable_pipes:
310	end if	311	end if
311	and byte [esi+7000Bh], not 80h ; PIPEACONF: disable pipe	312	and byte [esi+7000Bh], not 80h ; PIPEACONF: disable pipe
312	and byte [esi+7100Bh], not 80h ; PIPEBCONF: disable pipe	313	and byte [esi+7100Bh], not 80h ; PIPEBCONF: disable pipe
313	cmp [deviceType], gen4_start	314	cmp [deviceType], gen4_start
314	jb .wait_watching_scanline	315	jb .wait_watching_scanline
315	; g45 and later: use special flag from PIPE*CONF	316	; g45 and later: use special flag from PIPE*CONF
316	mov edx, 10000h	317	mov edx, 10000h
317	@@:	318	@@:
318	mov ecx, 1000h	319	mov ecx, 1000h
319	loop $	320	loop $
320	test byte [esi+7000Bh], 40h ; PIPEACONF: wait until pipe disabled	321	test byte [esi+7000Bh], 40h ; PIPEACONF: wait until pipe disabled
321	jz @f	322	jz @f
322	dec edx	323	dec edx
323	jnz @b	324	jnz @b
324	jmp .not_disabled	325	jmp .not_disabled
325	@@:	326	@@:
326	test byte [esi+7100Bh], 40h ; PIPEBCONF: wait until pipe disabled	327	test byte [esi+7100Bh], 40h ; PIPEBCONF: wait until pipe disabled
327	jz .disabled	328	jz .disabled
328	mov ecx, 1000h	329	mov ecx, 1000h
329	loop $	330	loop $
330	dec edx	331	dec edx
331	jnz @b	332	jnz @b
332	jmp .not_disabled	333	jmp .not_disabled
333	; pineview and before: wait while scanline still changes	334	; pineview and before: wait while scanline still changes
334	.wait_watching_scanline:	335	.wait_watching_scanline:
335	mov edx, 1000h	336	mov edx, 1000h
336	.dis1:	337	.dis1:
337	push dword [esi+71000h]	338	push dword [esi+71000h]
338	push dword [esi+70000h]	339	push dword [esi+70000h]
339	mov ecx, 10000h	340	mov ecx, 10000h
340	loop $	341	loop $
341	pop eax	342	pop eax
342	xor eax, [esi+70000h]	343	xor eax, [esi+70000h]
343	and eax, 1FFFh	344	and eax, 1FFFh
344	pop eax	345	pop eax
345	jnz .notdis1	346	jnz .notdis1
346	xor eax, [esi+71000h]	347	xor eax, [esi+71000h]
347	and eax, 1FFFh	348	and eax, 1FFFh
348	jz .disabled	349	jz .disabled
349	.notdis1:	350	.notdis1:
350	dec edx	351	dec edx
351	jnz .dis1	352	jnz .dis1
352	.not_disabled:	353	.not_disabled:
353	sti	354	sti
354	jmp .return	355	jmp .return
355	.disabled:	356	.disabled:
356	lea eax, [esi+61183h]	357	lea eax, [esi+61183h]
357	cmp [deviceType], ironlake_start	358	cmp [deviceType], ironlake_start
358	jb @f	359	jb @f
359	add eax, 0xE0000 - 0x60000	360	add eax, 0xE0000 - 0x60000
360	@@:	361	@@:
361	lea edx, [esi+60000h]	362	lea edx, [esi+60000h]
362	test byte [eax], 40h	363	test byte [eax], 40h
363	jz @f	364	jz @f
364	add edx, 1000h	365	add edx, 1000h
365	@@:	366	@@:
366	mov eax, [width]	367	mov eax, [width]
367	dec eax	368	dec eax
368	shl eax, 16	369	shl eax, 16
369	mov ax, word [height]	370	mov ax, word [height]
370	dec eax	371	dec eax
371	mov dword [edx+1Ch], eax ; PIPEASRC: set source image size	372	mov dword [edx+1Ch], eax ; PIPEASRC: set source image size
372	ror eax, 16	373	ror eax, 16
373	mov dword [edx+10190h], eax ; for old cards	374	mov dword [edx+10190h], eax ; for old cards
374	mov ecx, [width]	375	mov ecx, [width]
375	add ecx, 15	376	add ecx, 15
376	and ecx, not 15	377	and ecx, not 15
377	shl ecx, 2	378	shl ecx, 2
378	mov dword [edx+10188h], ecx ; DSPASTRIDE: set scanline length	379	mov dword [edx+10188h], ecx ; DSPASTRIDE: set scanline length
379	mov dword [edx+10184h], 0 ; DSPALINOFF: force write to DSPA* registers	380	mov dword [edx+10184h], 0 ; DSPALINOFF: force write to DSPA* registers
380	and byte [esi+61233h], not 80h ; PFIT_CONTROL: disable panel fitting	381	and byte [esi+61233h], not 80h ; PFIT_CONTROL: disable panel fitting
381	or byte [edx+1000Bh], 80h ; PIPEACONF: enable pipe	382	or byte [edx+1000Bh], 80h ; PIPEACONF: enable pipe
382	; and byte [edx+1000Ah], not 0Ch ; PIPEACONF: enable Display+Cursor Planes	383	; and byte [edx+1000Ah], not 0Ch ; PIPEACONF: enable Display+Cursor Planes
383	or byte [edx+10183h], 80h ; DSPACNTR: enable Display Plane A	384	or byte [edx+10183h], 80h ; DSPACNTR: enable Display Plane A
384	sti	385	sti
385	; 2. Notify the kernel that resolution has changed.	386	; 2. Notify the kernel that resolution has changed.
386	call GetDisplay	387	invoke GetDisplay
387	mov edx, [width]	388	mov edx, [width]
388	mov dword [eax+8], edx	389	mov dword [eax+8], edx
389	mov edx, [height]	390	mov edx, [height]
390	mov dword [eax+0Ch], edx	391	mov dword [eax+0Ch], edx
391	mov [eax+18h], ecx	392	mov [eax+18h], ecx
392	mov eax, [width]	393	mov eax, [width]
393	dec eax	394	dec eax
394	dec edx	395	dec edx
395	call SetScreen	396	invoke SetScreen
396	.return:	397	.return:
397	ret	398	ret
-		399
-		400	include '../peimport.inc'
-		401	data fixups
-		402	end data
398		403
399	align 4	404	align 4
400	hellomsg db 'Intel videocard detected, PciId=8086:'	405	hellomsg db 'Intel videocard detected, PciId=8086:'
401	pciid_text db '0000'	406	pciid_text db '0000'
402	db ', which is ', 0	407	db ', which is ', 0
403	knownmsg db 'known',13,10,0	408	knownmsg db 'known',13,10,0
404	unknownmsg db 'unknown',13,10,0	409	unknownmsg db 'unknown',13,10,0
405		410
406	if DEBUG	411	if DEBUG
407	edidmsg db 'EDID successfully read:',13,10	412	edidmsg db 'EDID successfully read:',13,10
408	edid_text rb 8(163+1)	413	edid_text rb 8(163+1)
409	db 0	414	db 0
410	end if	415	end if
411		-
412	version:	-
413	dd 0x50005	-
414		416
415	width dd predefined_width	417	width dd predefined_width
416	height dd predefined_height	418	height dd predefined_height
417		419
418	pciids:	420	pciids:
419	dw 0x3577 ; i830m	421	dw 0x3577 ; i830m
420	dw 0x2562 ; 845g	422	dw 0x2562 ; 845g
421	dw 0x3582 ; i855gm	423	dw 0x3582 ; i855gm
422	i865_start = ($ - pciids) / 2	424	i865_start = ($ - pciids) / 2
423	dw 0x2572 ; i865g	425	dw 0x2572 ; i865g
424	i9xx_start = ($ - pciids) / 2	426	i9xx_start = ($ - pciids) / 2
425	dw 0x2582 ; i915g	427	dw 0x2582 ; i915g
426	dw 0x258a ; e7221g (i915g)	428	dw 0x258a ; e7221g (i915g)
427	dw 0x2592 ; i915gm	429	dw 0x2592 ; i915gm
428	dw 0x2772 ; i945g	430	dw 0x2772 ; i945g
429	dw 0x27a2 ; i945gm	431	dw 0x27a2 ; i945gm
430	dw 0x27ae ; i945gme	432	dw 0x27ae ; i945gme
431	i965_start = ($ - pciids) / 2	433	i965_start = ($ - pciids) / 2
432	dw 0x2972 ; i946qz (i965g)	434	dw 0x2972 ; i946qz (i965g)
433	dw 0x2982 ; g35g (i965g)	435	dw 0x2982 ; g35g (i965g)
434	dw 0x2992 ; i965q (i965g)	436	dw 0x2992 ; i965q (i965g)
435	dw 0x29a2 ; i965g	437	dw 0x29a2 ; i965g
436	dw 0x29b2 ; q35g	438	dw 0x29b2 ; q35g
437	dw 0x29c2 ; g33g	439	dw 0x29c2 ; g33g
438	dw 0x29d2 ; q33g	440	dw 0x29d2 ; q33g
439	dw 0xa001 ; pineview	441	dw 0xa001 ; pineview
440	dw 0xa011 ; pineview	442	dw 0xa011 ; pineview
441	gen4_start = ($ - pciids) / 2	443	gen4_start = ($ - pciids) / 2
442	dw 0x2a02 ; i965gm	444	dw 0x2a02 ; i965gm
443	dw 0x2a12 ; i965gm	445	dw 0x2a12 ; i965gm
444	dw 0x2a42 ; gm45	446	dw 0x2a42 ; gm45
445	dw 0x2e02 ; g45	447	dw 0x2e02 ; g45
446	dw 0x2e12 ; g45	448	dw 0x2e12 ; g45
447	dw 0x2e22 ; g45	449	dw 0x2e22 ; g45
448	dw 0x2e32 ; g45	450	dw 0x2e32 ; g45
449	dw 0x2e42 ; g45	451	dw 0x2e42 ; g45
450	dw 0x2e92 ; g45	452	dw 0x2e92 ; g45
451	ironlake_start = ($ - pciids) / 2	453	ironlake_start = ($ - pciids) / 2
452	dw 0x0042 ; ironlake_d	454	dw 0x0042 ; ironlake_d
453	dw 0x0046 ; ironlake_m	455	dw 0x0046 ; ironlake_m
454	dw 0x0102 ; sandybridge_d	456	dw 0x0102 ; sandybridge_d
455	dw 0x0112 ; sandybridge_d	457	dw 0x0112 ; sandybridge_d
456	dw 0x0122 ; sandybridge_d	458	dw 0x0122 ; sandybridge_d
457	dw 0x0106 ; sandybridge_m	459	dw 0x0106 ; sandybridge_m
458	dw 0x0116 ; sandybridge_m	460	dw 0x0116 ; sandybridge_m
459	dw 0x0126 ; sandybridge_m	461	dw 0x0126 ; sandybridge_m
460	dw 0x010A ; sandybridge_d	462	dw 0x010A ; sandybridge_d
461	pciids_num = ($ - pciids) / 2	463	pciids_num = ($ - pciids) / 2
462		464
463	align 4	465	align 4
464	deviceType dd ?	466	deviceType dd ?
465	edid rb 0x80	467	edid rb 0x80

Subversion Repositories Kolibri OS

(root)/drivers/video/vidintel.asm – Rev 3708 → 5039