WebSVN – Kolibri OS – Diff – /kernel/trunk/init.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9958 $
 
align 4
proc mem_test
; if we have BIOS with fn E820, skip the test
        cmp     [BOOT_LO.memmap_block_cnt], 0
        jnz     .ret
 
        mov     eax, cr0
        and     eax, not (CR0_CD + CR0_NW)
        or      eax, CR0_CD       ;disable caching
        mov     cr0, eax
        wbinvd                    ;invalidate cache
 
        xor     edi, edi
        mov     ebx, 'TEST'
@@:
        add     edi, 0x100000
        xchg    ebx, dword [edi]
        cmp     dword [edi], 'TEST'
        xchg    ebx, dword [edi]
        je      @b
 
        and     eax, not (CR0_CD + CR0_NW) ;enable caching
        mov     cr0, eax
        inc     dword [BOOT_LO.memmap_block_cnt]
        xor     eax, eax
        mov     [BOOT_LO.memmap_blocks + e820entry.addr.lo], eax
        mov     [BOOT_LO.memmap_blocks + e820entry.addr.hi], eax
        mov     [BOOT_LO.memmap_blocks + e820entry.size.lo], edi
        mov     [BOOT_LO.memmap_blocks + e820entry.size.hi], eax
        inc     eax
        mov     [BOOT_LO.memmap_blocks + e820entry.type], eax
.ret:
        ret
endp
 
align 4
proc init_mem
; calculate maximum allocatable address and number of allocatable pages
        mov     edi, BOOT_LO.memmap_blocks
        mov     ecx, [edi-4]    ; memmap_block_cnt
        xor     esi, esi; esi will hold total amount of memory
        xor     edx, edx; edx will hold maximum allocatable address
.calcmax:
; round all to pages
        mov     eax, [edi + e820entry.addr.lo]
        cmp     byte [edi + e820entry.type], 1
        jne     .unusable
 
        test    eax, PAGE_SIZE-1
        jz      @f
        neg     eax
        and     eax, PAGE_SIZE-1
        add     [edi + e820entry.addr.lo], eax
        adc     [edi + e820entry.addr.hi], 0
        sub     [edi + e820entry.size.lo], eax
        sbb     [edi + e820entry.size.hi], 0
        jc      .unusable
@@:
        and     [edi + e820entry.size.lo], -PAGE_SIZE
        jz      .unusable
; ignore memory after 4 GiB
        cmp     [edi + e820entry.addr.hi], 0
        jnz     .unusable
        mov     eax, [edi + e820entry.addr.lo]
        cmp     [edi + e820entry.size.hi], 0
        jnz     .overflow
        add     eax, [edi + e820entry.size.lo]
        jnc     @f
.overflow:
        mov     eax, -PAGE_SIZE
@@:
        cmp     edx, eax
        jae     @f
        mov     edx, eax
@@:
        sub     eax, [edi + e820entry.addr.lo]
        mov     [edi + e820entry.size.lo], eax
        add     esi, eax
        jmp     .usable
.unusable:
;        and     dword [edi+e820entry.size.lo], 0
.usable:
        add     edi, sizeof.e820entry
        loop    .calcmax
.calculated:
        mov     [MEM_AMOUNT - OS_BASE], esi
        mov     [pg_data.mem_amount - OS_BASE], esi
        shr     esi, 12
        mov     [pg_data.pages_count - OS_BASE], esi
 
        shr     edx, 12
        add     edx, 31
        and     edx, not 31
        shr     edx, 3
        mov     [pg_data.pagemap_size - OS_BASE], edx
 
        add     edx, (sys_pgmap - OS_BASE)+PAGE_SIZE-1
        and     edx, -PAGE_SIZE
        mov     [tmp_page_tabs], edx
 
        mov     edx, esi
        and     edx, -1024
        cmp     edx, (OS_BASE/PAGE_SIZE)
        jbe     @F
        mov     edx, (OS_BASE/PAGE_SIZE)
        jmp     .set
@@:
        cmp     edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE
        jae     .set
        mov     edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE
.set:
        mov     [pg_data.kernel_pages - OS_BASE], edx
        shr     edx, 10
        mov     [pg_data.kernel_tables - OS_BASE], edx
 
        xor     eax, eax
        mov     edi, sys_proc - OS_BASE
        mov     ecx, 2*PAGE_SIZE/4
        cld
        rep stosd
 
        mov     edx, (sys_proc - OS_BASE + PROC.pdt_0) + (OS_BASE shr 20)
        bt      [cpu_caps - OS_BASE], CAPS_PSE
        jnc     .no_PSE
 
        mov     ebx, cr4
        or      ebx, CR4_PSE
        mov     eax, PDE_LARGE + PG_SWR
        mov     cr4, ebx
        dec     [pg_data.kernel_tables - OS_BASE]
 
        mov     [edx], eax
        add     edx, 4
 
        mov     edi, [tmp_page_tabs]
        jmp     .map_kernel_heap        ; new kernel fits to the first 4Mb - nothing to do with ".map_low"
.no_PSE:
        mov     eax, PG_SWR
        mov     ecx, [tmp_page_tabs]
        shr     ecx, 12
.map_low:
        mov     edi, [tmp_page_tabs]
@@:                                   ;
        stosd
        add     eax, PAGE_SIZE
        dec     ecx
        jnz     @B
 
.map_kernel_heap:
        mov     ecx, [pg_data.kernel_tables - OS_BASE]
        shl     ecx, 10
        xor     eax, eax
        rep stosd
 
        mov     ecx, [pg_data.kernel_tables - OS_BASE]
        mov     eax, [tmp_page_tabs]
        or      eax, PG_SWR
        mov     edi, edx
 
.map_kernel_tabs:
        stosd
        add     eax, PAGE_SIZE
        dec     ecx
        jnz     .map_kernel_tabs
 
        mov     dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)], sys_proc+PROC.pdt_0+PG_SWR-OS_BASE
 
        mov     edi, (sys_proc + PROC.pdt_0 - OS_BASE)
        lea     esi, [edi + (OS_BASE shr 20)]
        movsd
        movsd
        ret
endp
 
align 4
proc init_page_map
; mark all memory as unavailable
        mov     edi, sys_pgmap - OS_BASE
        mov     ecx, [pg_data.pagemap_size - OS_BASE]
        shr     ecx, 2
        xor     eax, eax
        cld
        rep stosd
 
; scan through memory map and mark free areas as available
        mov     ebx, BOOT_LO.memmap_blocks
        mov     edx, [ebx-4]
.scanmap:
        cmp     byte [ebx + e820entry.type], 1
        jne     .next
 
        mov     ecx, [ebx + e820entry.size.lo]
        shr     ecx, 12; ecx = number of pages
        jz      .next
        mov     edi, [ebx + e820entry.addr.lo]
        shr     edi, 12; edi = first page
        mov     eax, edi
        shr     edi, 5
        shl     edi, 2
        add     edi, sys_pgmap - OS_BASE
        and     eax, 31
        jz      .startok
        add     ecx, eax
        sub     ecx, 32
        jbe     .onedword
        push    ecx
        mov     ecx, eax
        or      eax, -1
        shl     eax, cl
        or      [edi], eax
        add     edi, 4
        pop     ecx
.startok:
        push    ecx
        shr     ecx, 5
        or      eax, -1
        rep stosd
        pop     ecx
        and     ecx, 31
        neg     eax
        shl     eax, cl
        dec     eax
        or      [edi], eax
        jmp     .next
.onedword:
        add     ecx, 32
        sub     ecx, eax
@@:
        bts     [edi], eax
        inc     eax
        loop    @b
.next:
        add     ebx, sizeof.e820entry
        dec     edx
        jnz     .scanmap
 
; mark kernel memory as allocated (unavailable)
        mov     ecx, [tmp_page_tabs]
        mov     edx, [pg_data.pages_count - OS_BASE]
        shr     ecx, 12
        add     ecx, [pg_data.kernel_tables - OS_BASE]
        sub     edx, ecx
        mov     [pg_data.pages_free - OS_BASE], edx
 
        mov     edi, sys_pgmap - OS_BASE
        mov     ebx, ecx
        shr     ecx, 5
        xor     eax, eax
        rep stosd
 
        not     eax
        mov     ecx, ebx
        and     ecx, 31
        shl     eax, cl
        and     [edi], eax
        add     edi, OS_BASE
        mov     [page_start - OS_BASE], edi;
 
        mov     ebx, sys_pgmap
        add     ebx, [pg_data.pagemap_size - OS_BASE]
        mov     [page_end - OS_BASE], ebx
 
        ret
endp
 
align 4
 
init_BIOS32:
        mov     edi, 0xE0000
.pcibios_nxt:
        cmp     dword[edi], '_32_'; "magic" word
        je      .BIOS32_found
.pcibios_nxt2:
        add     edi, 0x10
        cmp     edi, 0xFFFF0
        je      .BIOS32_not_found
        jmp     .pcibios_nxt
.BIOS32_found:                  ; magic word found, check control summ
 
        movzx   ecx, byte[edi + 9]
        shl     ecx, 4
        mov     esi, edi
        xor     eax, eax
        cld      ; paranoia
@@:
        lodsb
        add     ah, al
        loop    @b
        jnz     .pcibios_nxt2; control summ must be zero
    ; BIOS32 service found !
        mov     ebp, [edi + 4]
        mov     [bios32_entry], ebp
    ; check PCI BIOS present
        mov     eax, '$PCI'
        xor     ebx, ebx
        push    cs  ; special for 'ret far' from  BIOS
        call    ebp
        test    al, al
        jnz     .PCI_BIOS32_not_found
 
 ; descriptors for PCI BIOS are created here
 
        add     ebx, OS_BASE
        dec     ecx
        mov     [(pci_code_32 - OS_BASE)], cx   ;limit 0-15
        mov     [(pci_data_32 - OS_BASE)], cx   ;limit 0-15
 
        mov     [(pci_code_32 - OS_BASE)+2], bx ;base  0-15
        mov     [(pci_data_32 - OS_BASE)+2], bx ;base  0-15
 
        shr     ebx, 16
        mov     [(pci_code_32 - OS_BASE)+4], bl ;base  16-23
        mov     [(pci_data_32 - OS_BASE)+4], bl ;base  16-23
 
        shr     ecx, 16
        and     cl, 0x0F
        mov     ch, bh
        add     cx, D32
        mov     [(pci_code_32 - OS_BASE)+6], cx ;lim   16-19 &
        mov     [(pci_data_32 - OS_BASE)+6], cx ;base  24-31
 
        mov     [(pci_bios_entry - OS_BASE)], edx
         ; jmp .end
.PCI_BIOS32_not_found:
        ; pci_emu_dat structure should be filled here
.BIOS32_not_found:
.end:
        ret
 
align 4
proc test_cpu
           locals
              cpu_type   dd ?
           endl
 
        xor     eax, eax
        mov     [cpu_type], eax
        mov     [cpu_caps - OS_BASE], eax
        mov     [cpu_caps + 4 - OS_BASE], eax
        mov     [cpu_phys_addr_width - OS_BASE], 32
 
        pushfd
        pop     eax
        mov     ecx, eax
        xor     eax, EFLAGS_AC
        push    eax
        popfd
        pushfd
        pop     eax
        xor     eax, ecx
        mov     [cpu_type], CPU_386
        jz      .end_cpuid
        push    ecx
        popfd
 
        mov     [cpu_type], CPU_486
        mov     eax, ecx
        xor     eax, EFLAGS_ID
        push    eax
        popfd
        pushfd
        pop     eax
        xor     eax, ecx
        je      .end_cpuid
 
        xor     eax, eax
        cpuid
 
        mov     [cpu_vendor - OS_BASE], ebx
        mov     [cpu_vendor + 4 - OS_BASE], edx
        mov     [cpu_vendor + 8 - OS_BASE], ecx
 
        cmp     eax, 1
        jl      .end_cpuid
        mov     eax, 1
        cpuid
        mov     [cpu_sign - OS_BASE], eax
        mov     [cpu_info - OS_BASE], ebx
        mov     [cpu_caps - OS_BASE], edx
        mov     [cpu_caps + 4 - OS_BASE], ecx
 
        bt      edx, CAPS_PAE
        jnc     @f
        mov     [cpu_phys_addr_width - OS_BASE], 36
@@:
        mov     eax, 0x80000000
        cpuid
        cmp     eax, 0x80000008
        jb      @f
        mov     eax, 0x80000008
        cpuid
        mov     [cpu_phys_addr_width - OS_BASE], al
@@:
 
        mov     eax, [cpu_sign - OS_BASE]
        shr     eax, 8
        and     eax, 0x0f
        ret
.end_cpuid:
        mov     eax, [cpu_type]
        ret
endp
 
 
 
ACPI_RSDP_CHECKSUM_LENGTH  = 20
 
proc acpi_locate_tables uses ebx esi edi
        mov     ebx, [ebx + ACPI_RSDP.RsdtAddress]
        mov     [acpi_rsdt_base - OS_BASE], ebx
        mov     eax, [ebx + ACPI_RSDT.Length]
        mov     [acpi_rsdt_size - OS_BASE], eax
 
        mov     esi, [acpi_rsdt_base - OS_BASE]
        mov     ecx, [esi + ACPI_RSDT.Length]
        lea     edi, [esi + ecx]
        add     esi, sizeof.ACPI_TABLE
        movi    ecx, 1
.next_table:
        cmp     esi, edi
        jae     .done
        lodsd
        cmp     [eax+ACPI_TABLE.Signature], 'SSDT'      ; skip DSDT if present
        jz      .ssdt                                   ; read it from FADT
        cmp     [eax+ACPI_TABLE.Signature], 'FACP'      ; this is FADT
        jz      .fadt
        cmp     [eax+ACPI_TABLE.Signature], 'APIC'      ; this is MADT
        jz      .madt
        cmp     [eax+ACPI_TABLE.Signature], 'HPET'
        jz      .hpet
        jmp     .next_table
.ssdt:
        mov     [acpi_ssdt_base + ecx*4 - OS_BASE], eax
        mov     eax, [eax+ACPI_TABLE.Length]
        mov     [acpi_ssdt_size + ecx*4 - OS_BASE], eax
        inc     ecx
        jmp     .next_table
.fadt:
        mov     [acpi_fadt_base - OS_BASE], eax
        cmp     [eax + ACPI_FADT.DSDT], 0
        jz      @f
        mov     edx, [eax + ACPI_FADT.DSDT]
        mov     [acpi_ssdt_base - OS_BASE], edx
        mov     edx, [edx + ACPI_TABLE.Length]
        mov     [acpi_ssdt_size - OS_BASE], edx
@@:
        mov     eax, [eax + ACPI_TABLE.Length]
        mov     [acpi_fadt_size - OS_BASE], eax
        jmp     .next_table
.madt:
        mov     [acpi_madt_base - OS_BASE], eax
        mov     eax, [eax + ACPI_TABLE.Length]
        mov     [acpi_madt_size - OS_BASE], eax
        jmp     .next_table
.hpet:
        mov     [acpi_hpet_base - OS_BASE], eax
        mov     eax, [eax + ACPI_TABLE.Length]
        mov     [acpi_hpet_size - OS_BASE], eax
        jmp     .next_table
.done:
        mov     [acpi_ssdt_cnt - OS_BASE], ecx
        ret
endp
 
acpi_locate:
        push    ebx
        push    edi
 
 
 
        mov     ebx, [BOOT_LO.acpi_rsdp]
        test    ebx, ebx
        jz      .done
        mov     edi, ebx
        call    .check
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
.done:
        mov     [acpi_rsdp_base - OS_BASE], ebx
        test    ebx, ebx
        jz      @f
        call    acpi_locate_tables
@@:
        pop     edi
        pop     ebx
        ret
 
.check:
        cmp     [ebx], dword 'RSD '
        jne     .next
        cmp     [ebx+4], dword 'PTR '
        jne     .next
 
        mov     edx, ebx
        mov     ecx, ACPI_RSDP_CHECKSUM_LENGTH
        xor     eax, eax
.sum:
        add     al, [edx]
        inc     edx
        loop    .sum
 
        test    al, al
        jnz     .next
        ret
.next:
        add     ebx, 16
        cmp     ebx, edi
        jb      .check
        xor     ebx, ebx
        ret

Rev 9899	Rev 9958
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 9899 $	8	$Revision: 9958 $
9		9
10	align 4	10	align 4
11	proc mem_test	11	proc mem_test
12	; if we have BIOS with fn E820, skip the test	12	; if we have BIOS with fn E820, skip the test
13	cmp [BOOT_LO.memmap_block_cnt], 0	13	cmp [BOOT_LO.memmap_block_cnt], 0
14	jnz .ret	14	jnz .ret
15		15
16	mov eax, cr0	16	mov eax, cr0
17	and eax, not (CR0_CD + CR0_NW)	17	and eax, not (CR0_CD + CR0_NW)
18	or eax, CR0_CD ;disable caching	18	or eax, CR0_CD ;disable caching
19	mov cr0, eax	19	mov cr0, eax
20	wbinvd ;invalidate cache	20	wbinvd ;invalidate cache
21		21
22	xor edi, edi	22	xor edi, edi
23	mov ebx, 'TEST'	23	mov ebx, 'TEST'
24	@@:	24	@@:
25	add edi, 0x100000	25	add edi, 0x100000
26	xchg ebx, dword [edi]	26	xchg ebx, dword [edi]
27	cmp dword [edi], 'TEST'	27	cmp dword [edi], 'TEST'
28	xchg ebx, dword [edi]	28	xchg ebx, dword [edi]
29	je @b	29	je @b
30		30
31	and eax, not (CR0_CD + CR0_NW) ;enable caching	31	and eax, not (CR0_CD + CR0_NW) ;enable caching
32	mov cr0, eax	32	mov cr0, eax
33	inc dword [BOOT_LO.memmap_block_cnt]	33	inc dword [BOOT_LO.memmap_block_cnt]
34	xor eax, eax	34	xor eax, eax
35	mov [BOOT_LO.memmap_blocks + e820entry.addr.lo], eax	35	mov [BOOT_LO.memmap_blocks + e820entry.addr.lo], eax
36	mov [BOOT_LO.memmap_blocks + e820entry.addr.hi], eax	36	mov [BOOT_LO.memmap_blocks + e820entry.addr.hi], eax
37	mov [BOOT_LO.memmap_blocks + e820entry.size.lo], edi	37	mov [BOOT_LO.memmap_blocks + e820entry.size.lo], edi
38	mov [BOOT_LO.memmap_blocks + e820entry.size.hi], eax	38	mov [BOOT_LO.memmap_blocks + e820entry.size.hi], eax
39	inc eax	39	inc eax
40	mov [BOOT_LO.memmap_blocks + e820entry.type], eax	40	mov [BOOT_LO.memmap_blocks + e820entry.type], eax
41	.ret:	41	.ret:
42	ret	42	ret
43	endp	43	endp
44		44
45	align 4	45	align 4
46	proc init_mem	46	proc init_mem
47	; calculate maximum allocatable address and number of allocatable pages	47	; calculate maximum allocatable address and number of allocatable pages
48	mov edi, BOOT_LO.memmap_blocks	48	mov edi, BOOT_LO.memmap_blocks
49	mov ecx, [edi-4] ; memmap_block_cnt	49	mov ecx, [edi-4] ; memmap_block_cnt
50	xor esi, esi; esi will hold total amount of memory	50	xor esi, esi; esi will hold total amount of memory
51	xor edx, edx; edx will hold maximum allocatable address	51	xor edx, edx; edx will hold maximum allocatable address
52	.calcmax:	52	.calcmax:
53	; round all to pages	53	; round all to pages
54	mov eax, [edi + e820entry.addr.lo]	54	mov eax, [edi + e820entry.addr.lo]
55	cmp byte [edi + e820entry.type], 1	55	cmp byte [edi + e820entry.type], 1
56	jne .unusable	56	jne .unusable
57		57
58	test eax, PAGE_SIZE-1	58	test eax, PAGE_SIZE-1
59	jz @f	59	jz @f
60	neg eax	60	neg eax
61	and eax, PAGE_SIZE-1	61	and eax, PAGE_SIZE-1
62	add [edi + e820entry.addr.lo], eax	62	add [edi + e820entry.addr.lo], eax
63	adc [edi + e820entry.addr.hi], 0	63	adc [edi + e820entry.addr.hi], 0
64	sub [edi + e820entry.size.lo], eax	64	sub [edi + e820entry.size.lo], eax
65	sbb [edi + e820entry.size.hi], 0	65	sbb [edi + e820entry.size.hi], 0
66	jc .unusable	66	jc .unusable
67	@@:	67	@@:
68	and [edi + e820entry.size.lo], -PAGE_SIZE	68	and [edi + e820entry.size.lo], -PAGE_SIZE
69	jz .unusable	69	jz .unusable
70	; ignore memory after 4 GiB	70	; ignore memory after 4 GiB
71	cmp [edi + e820entry.addr.hi], 0	71	cmp [edi + e820entry.addr.hi], 0
72	jnz .unusable	72	jnz .unusable
73	mov eax, [edi + e820entry.addr.lo]	73	mov eax, [edi + e820entry.addr.lo]
74	cmp [edi + e820entry.size.hi], 0	74	cmp [edi + e820entry.size.hi], 0
75	jnz .overflow	75	jnz .overflow
76	add eax, [edi + e820entry.size.lo]	76	add eax, [edi + e820entry.size.lo]
77	jnc @f	77	jnc @f
78	.overflow:	78	.overflow:
79	mov eax, -PAGE_SIZE	79	mov eax, -PAGE_SIZE
80	@@:	80	@@:
81	cmp edx, eax	81	cmp edx, eax
82	jae @f	82	jae @f
83	mov edx, eax	83	mov edx, eax
84	@@:	84	@@:
85	sub eax, [edi + e820entry.addr.lo]	85	sub eax, [edi + e820entry.addr.lo]
86	mov [edi + e820entry.size.lo], eax	86	mov [edi + e820entry.size.lo], eax
87	add esi, eax	87	add esi, eax
88	jmp .usable	88	jmp .usable
89	.unusable:	89	.unusable:
90	; and dword [edi+e820entry.size.lo], 0	90	; and dword [edi+e820entry.size.lo], 0
91	.usable:	91	.usable:
92	add edi, sizeof.e820entry	92	add edi, sizeof.e820entry
93	loop .calcmax	93	loop .calcmax
94	.calculated:	94	.calculated:
95	mov [MEM_AMOUNT - OS_BASE], esi	95	mov [MEM_AMOUNT - OS_BASE], esi
96	mov [pg_data.mem_amount - OS_BASE], esi	96	mov [pg_data.mem_amount - OS_BASE], esi
97	shr esi, 12	97	shr esi, 12
98	mov [pg_data.pages_count - OS_BASE], esi	98	mov [pg_data.pages_count - OS_BASE], esi
99		99
100	shr edx, 12	100	shr edx, 12
101	add edx, 31	101	add edx, 31
102	and edx, not 31	102	and edx, not 31
103	shr edx, 3	103	shr edx, 3
104	mov [pg_data.pagemap_size - OS_BASE], edx	104	mov [pg_data.pagemap_size - OS_BASE], edx
105		105
106	add edx, (sys_pgmap - OS_BASE)+PAGE_SIZE-1	106	add edx, (sys_pgmap - OS_BASE)+PAGE_SIZE-1
107	and edx, -PAGE_SIZE	107	and edx, -PAGE_SIZE
108	mov [tmp_page_tabs], edx	108	mov [tmp_page_tabs], edx
109		109
110	mov edx, esi	110	mov edx, esi
111	and edx, -1024	111	and edx, -1024
112	cmp edx, (OS_BASE/PAGE_SIZE)	112	cmp edx, (OS_BASE/PAGE_SIZE)
113	jbe @F	113	jbe @F
114	mov edx, (OS_BASE/PAGE_SIZE)	114	mov edx, (OS_BASE/PAGE_SIZE)
115	jmp .set	115	jmp .set
116	@@:	116	@@:
117	cmp edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE	117	cmp edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE
118	jae .set	118	jae .set
119	mov edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE	119	mov edx, (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE
120	.set:	120	.set:
121	mov [pg_data.kernel_pages - OS_BASE], edx	121	mov [pg_data.kernel_pages - OS_BASE], edx
122	shr edx, 10	122	shr edx, 10
123	mov [pg_data.kernel_tables - OS_BASE], edx	123	mov [pg_data.kernel_tables - OS_BASE], edx
124		124
125	xor eax, eax	125	xor eax, eax
126	mov edi, sys_proc - OS_BASE	126	mov edi, sys_proc - OS_BASE
127	mov ecx, 2*PAGE_SIZE/4	127	mov ecx, 2*PAGE_SIZE/4
128	cld	128	cld
129	rep stosd	129	rep stosd
130		130
131	mov edx, (sys_proc - OS_BASE + PROC.pdt_0) + (OS_BASE shr 20)	131	mov edx, (sys_proc - OS_BASE + PROC.pdt_0) + (OS_BASE shr 20)
132	bt [cpu_caps - OS_BASE], CAPS_PSE	132	bt [cpu_caps - OS_BASE], CAPS_PSE
133	jnc .no_PSE	133	jnc .no_PSE
134		134
135	mov ebx, cr4	135	mov ebx, cr4
136	or ebx, CR4_PSE	136	or ebx, CR4_PSE
137	mov eax, PDE_LARGE + PG_SWR	137	mov eax, PDE_LARGE + PG_SWR
138	mov cr4, ebx	138	mov cr4, ebx
139	dec [pg_data.kernel_tables - OS_BASE]	139	dec [pg_data.kernel_tables - OS_BASE]
140		140
141	mov [edx], eax	141	mov [edx], eax
142	add edx, 4	142	add edx, 4
143		143
144	mov edi, [tmp_page_tabs]	144	mov edi, [tmp_page_tabs]
145	jmp .map_kernel_heap ; new kernel fits to the first 4Mb - nothing to do with ".map_low"	145	jmp .map_kernel_heap ; new kernel fits to the first 4Mb - nothing to do with ".map_low"
146	.no_PSE:	146	.no_PSE:
147	mov eax, PG_SWR	147	mov eax, PG_SWR
148	mov ecx, [tmp_page_tabs]	148	mov ecx, [tmp_page_tabs]
149	shr ecx, 12	149	shr ecx, 12
150	.map_low:	150	.map_low:
151	mov edi, [tmp_page_tabs]	151	mov edi, [tmp_page_tabs]
152	@@: ;	152	@@: ;
153	stosd	153	stosd
154	add eax, PAGE_SIZE	154	add eax, PAGE_SIZE
155	dec ecx	155	dec ecx
156	jnz @B	156	jnz @B
157		157
158	.map_kernel_heap:	158	.map_kernel_heap:
159	mov ecx, [pg_data.kernel_tables - OS_BASE]	159	mov ecx, [pg_data.kernel_tables - OS_BASE]
160	shl ecx, 10	160	shl ecx, 10
161	xor eax, eax	161	xor eax, eax
162	rep stosd	162	rep stosd
163		163
164	mov ecx, [pg_data.kernel_tables - OS_BASE]	164	mov ecx, [pg_data.kernel_tables - OS_BASE]
165	mov eax, [tmp_page_tabs]	165	mov eax, [tmp_page_tabs]
166	or eax, PG_SWR	166	or eax, PG_SWR
167	mov edi, edx	167	mov edi, edx
168		168
169	.map_kernel_tabs:	169	.map_kernel_tabs:
170	stosd	170	stosd
171	add eax, PAGE_SIZE	171	add eax, PAGE_SIZE
172	dec ecx	172	dec ecx
173	jnz .map_kernel_tabs	173	jnz .map_kernel_tabs
174		174
175	mov dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)], sys_proc+PROC.pdt_0+PG_SWR-OS_BASE	175	mov dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)], sys_proc+PROC.pdt_0+PG_SWR-OS_BASE
176		176
177	mov edi, (sys_proc + PROC.pdt_0 - OS_BASE)	177	mov edi, (sys_proc + PROC.pdt_0 - OS_BASE)
178	lea esi, [edi + (OS_BASE shr 20)]	178	lea esi, [edi + (OS_BASE shr 20)]
179	movsd	179	movsd
180	movsd	180	movsd
181	ret	181	ret
182	endp	182	endp
183		183
184	align 4	184	align 4
185	proc init_page_map	185	proc init_page_map
186	; mark all memory as unavailable	186	; mark all memory as unavailable
187	mov edi, sys_pgmap - OS_BASE	187	mov edi, sys_pgmap - OS_BASE
188	mov ecx, [pg_data.pagemap_size - OS_BASE]	188	mov ecx, [pg_data.pagemap_size - OS_BASE]
189	shr ecx, 2	189	shr ecx, 2
190	xor eax, eax	190	xor eax, eax
191	cld	191	cld
192	rep stosd	192	rep stosd
193		193
194	; scan through memory map and mark free areas as available	194	; scan through memory map and mark free areas as available
195	mov ebx, BOOT_LO.memmap_blocks	195	mov ebx, BOOT_LO.memmap_blocks
196	mov edx, [ebx-4]	196	mov edx, [ebx-4]
197	.scanmap:	197	.scanmap:
198	cmp byte [ebx + e820entry.type], 1	198	cmp byte [ebx + e820entry.type], 1
199	jne .next	199	jne .next
200		200
201	mov ecx, [ebx + e820entry.size.lo]	201	mov ecx, [ebx + e820entry.size.lo]
202	shr ecx, 12; ecx = number of pages	202	shr ecx, 12; ecx = number of pages
203	jz .next	203	jz .next
204	mov edi, [ebx + e820entry.addr.lo]	204	mov edi, [ebx + e820entry.addr.lo]
205	shr edi, 12; edi = first page	205	shr edi, 12; edi = first page
206	mov eax, edi	206	mov eax, edi
207	shr edi, 5	207	shr edi, 5
208	shl edi, 2	208	shl edi, 2
209	add edi, sys_pgmap - OS_BASE	209	add edi, sys_pgmap - OS_BASE
210	and eax, 31	210	and eax, 31
211	jz .startok	211	jz .startok
212	add ecx, eax	212	add ecx, eax
213	sub ecx, 32	213	sub ecx, 32
214	jbe .onedword	214	jbe .onedword
215	push ecx	215	push ecx
216	mov ecx, eax	216	mov ecx, eax
217	or eax, -1	217	or eax, -1
218	shl eax, cl	218	shl eax, cl
219	or [edi], eax	219	or [edi], eax
220	add edi, 4	220	add edi, 4
221	pop ecx	221	pop ecx
222	.startok:	222	.startok:
223	push ecx	223	push ecx
224	shr ecx, 5	224	shr ecx, 5
225	or eax, -1	225	or eax, -1
226	rep stosd	226	rep stosd
227	pop ecx	227	pop ecx
228	and ecx, 31	228	and ecx, 31
229	neg eax	229	neg eax
230	shl eax, cl	230	shl eax, cl
231	dec eax	231	dec eax
232	or [edi], eax	232	or [edi], eax
233	jmp .next	233	jmp .next
234	.onedword:	234	.onedword:
235	add ecx, 32	235	add ecx, 32
236	sub ecx, eax	236	sub ecx, eax
237	@@:	237	@@:
238	bts [edi], eax	238	bts [edi], eax
239	inc eax	239	inc eax
240	loop @b	240	loop @b
241	.next:	241	.next:
242	add ebx, sizeof.e820entry	242	add ebx, sizeof.e820entry
243	dec edx	243	dec edx
244	jnz .scanmap	244	jnz .scanmap
245		245
246	; mark kernel memory as allocated (unavailable)	246	; mark kernel memory as allocated (unavailable)
247	mov ecx, [tmp_page_tabs]	247	mov ecx, [tmp_page_tabs]
248	mov edx, [pg_data.pages_count - OS_BASE]	248	mov edx, [pg_data.pages_count - OS_BASE]
249	shr ecx, 12	249	shr ecx, 12
250	add ecx, [pg_data.kernel_tables - OS_BASE]	250	add ecx, [pg_data.kernel_tables - OS_BASE]
251	sub edx, ecx	251	sub edx, ecx
252	mov [pg_data.pages_free - OS_BASE], edx	252	mov [pg_data.pages_free - OS_BASE], edx
253		253
254	mov edi, sys_pgmap - OS_BASE	254	mov edi, sys_pgmap - OS_BASE
255	mov ebx, ecx	255	mov ebx, ecx
256	shr ecx, 5	256	shr ecx, 5
257	xor eax, eax	257	xor eax, eax
258	rep stosd	258	rep stosd
259		259
260	not eax	260	not eax
261	mov ecx, ebx	261	mov ecx, ebx
262	and ecx, 31	262	and ecx, 31
263	shl eax, cl	263	shl eax, cl
264	and [edi], eax	264	and [edi], eax
265	add edi, OS_BASE	265	add edi, OS_BASE
266	mov [page_start - OS_BASE], edi;	266	mov [page_start - OS_BASE], edi;
267		267
268	mov ebx, sys_pgmap	268	mov ebx, sys_pgmap
269	add ebx, [pg_data.pagemap_size - OS_BASE]	269	add ebx, [pg_data.pagemap_size - OS_BASE]
270	mov [page_end - OS_BASE], ebx	270	mov [page_end - OS_BASE], ebx
271		271
272	ret	272	ret
273	endp	273	endp
274		274
275	align 4	275	align 4
276		276
277	init_BIOS32:	277	init_BIOS32:
278	mov edi, 0xE0000	278	mov edi, 0xE0000
279	.pcibios_nxt:	279	.pcibios_nxt:
280	cmp dword[edi], '_32_'; "magic" word	280	cmp dword[edi], '_32_'; "magic" word
281	je .BIOS32_found	281	je .BIOS32_found
282	.pcibios_nxt2:	282	.pcibios_nxt2:
283	add edi, 0x10	283	add edi, 0x10
284	cmp edi, 0xFFFF0	284	cmp edi, 0xFFFF0
285	je .BIOS32_not_found	285	je .BIOS32_not_found
286	jmp .pcibios_nxt	286	jmp .pcibios_nxt
287	.BIOS32_found: ; magic word found, check control summ	287	.BIOS32_found: ; magic word found, check control summ
288		288
289	movzx ecx, byte[edi + 9]	289	movzx ecx, byte[edi + 9]
290	shl ecx, 4	290	shl ecx, 4
291	mov esi, edi	291	mov esi, edi
292	xor eax, eax	292	xor eax, eax
293	cld ; paranoia	293	cld ; paranoia
294	@@:	294	@@:
295	lodsb	295	lodsb
296	add ah, al	296	add ah, al
297	loop @b	297	loop @b
298	jnz .pcibios_nxt2; control summ must be zero	298	jnz .pcibios_nxt2; control summ must be zero
299	; BIOS32 service found !	299	; BIOS32 service found !
300	mov ebp, [edi + 4]	300	mov ebp, [edi + 4]
301	mov [bios32_entry], ebp	301	mov [bios32_entry], ebp
302	; check PCI BIOS present	302	; check PCI BIOS present
303	mov eax, '$PCI'	303	mov eax, '$PCI'
304	xor ebx, ebx	304	xor ebx, ebx
305	push cs ; special for 'ret far' from BIOS	305	push cs ; special for 'ret far' from BIOS
306	call ebp	306	call ebp
307	test al, al	307	test al, al
308	jnz .PCI_BIOS32_not_found	308	jnz .PCI_BIOS32_not_found
309		309
310	; descriptors for PCI BIOS are created here	310	; descriptors for PCI BIOS are created here
311		311
312	add ebx, OS_BASE	312	add ebx, OS_BASE
313	dec ecx	313	dec ecx
314	mov [(pci_code_32 - OS_BASE)], cx ;limit 0-15	314	mov [(pci_code_32 - OS_BASE)], cx ;limit 0-15
315	mov [(pci_data_32 - OS_BASE)], cx ;limit 0-15	315	mov [(pci_data_32 - OS_BASE)], cx ;limit 0-15
316		316
317	mov [(pci_code_32 - OS_BASE)+2], bx ;base 0-15	317	mov [(pci_code_32 - OS_BASE)+2], bx ;base 0-15
318	mov [(pci_data_32 - OS_BASE)+2], bx ;base 0-15	318	mov [(pci_data_32 - OS_BASE)+2], bx ;base 0-15
319		319
320	shr ebx, 16	320	shr ebx, 16
321	mov [(pci_code_32 - OS_BASE)+4], bl ;base 16-23	321	mov [(pci_code_32 - OS_BASE)+4], bl ;base 16-23
322	mov [(pci_data_32 - OS_BASE)+4], bl ;base 16-23	322	mov [(pci_data_32 - OS_BASE)+4], bl ;base 16-23
323		323
324	shr ecx, 16	324	shr ecx, 16
325	and cl, 0x0F	325	and cl, 0x0F
326	mov ch, bh	326	mov ch, bh
327	add cx, D32	327	add cx, D32
328	mov [(pci_code_32 - OS_BASE)+6], cx ;lim 16-19 &	328	mov [(pci_code_32 - OS_BASE)+6], cx ;lim 16-19 &
329	mov [(pci_data_32 - OS_BASE)+6], cx ;base 24-31	329	mov [(pci_data_32 - OS_BASE)+6], cx ;base 24-31
330		330
331	mov [(pci_bios_entry - OS_BASE)], edx	331	mov [(pci_bios_entry - OS_BASE)], edx
332	; jmp .end	332	; jmp .end
333	.PCI_BIOS32_not_found:	333	.PCI_BIOS32_not_found:
334	; pci_emu_dat structure should be filled here	334	; pci_emu_dat structure should be filled here
335	.BIOS32_not_found:	335	.BIOS32_not_found:
336	.end:	336	.end:
337	ret	337	ret
338		338
339	align 4	339	align 4
340	proc test_cpu	340	proc test_cpu
341	locals	341	locals
342	cpu_type dd ?	342	cpu_type dd ?
343	endl	343	endl
344		344
345	xor eax, eax	345	xor eax, eax
346	mov [cpu_type], eax	346	mov [cpu_type], eax
347	mov [cpu_caps - OS_BASE], eax	347	mov [cpu_caps - OS_BASE], eax
348	mov [cpu_caps + 4 - OS_BASE], eax	348	mov [cpu_caps + 4 - OS_BASE], eax
349	mov [cpu_phys_addr_width - OS_BASE], 32	349	mov [cpu_phys_addr_width - OS_BASE], 32
350		350
351	pushfd	351	pushfd
352	pop eax	352	pop eax
353	mov ecx, eax	353	mov ecx, eax
354	xor eax, EFLAGS_AC	354	xor eax, EFLAGS_AC
355	push eax	355	push eax
356	popfd	356	popfd
357	pushfd	357	pushfd
358	pop eax	358	pop eax
359	xor eax, ecx	359	xor eax, ecx
360	mov [cpu_type], CPU_386	360	mov [cpu_type], CPU_386
361	jz .end_cpuid	361	jz .end_cpuid
362	push ecx	362	push ecx
363	popfd	363	popfd
364		364
365	mov [cpu_type], CPU_486	365	mov [cpu_type], CPU_486
366	mov eax, ecx	366	mov eax, ecx
367	xor eax, EFLAGS_ID	367	xor eax, EFLAGS_ID
368	push eax	368	push eax
369	popfd	369	popfd
370	pushfd	370	pushfd
371	pop eax	371	pop eax
372	xor eax, ecx	372	xor eax, ecx
373	je .end_cpuid	373	je .end_cpuid
374		374
375	xor eax, eax	375	xor eax, eax
376	cpuid	376	cpuid
377		377
378	mov [cpu_vendor - OS_BASE], ebx	378	mov [cpu_vendor - OS_BASE], ebx
379	mov [cpu_vendor + 4 - OS_BASE], edx	379	mov [cpu_vendor + 4 - OS_BASE], edx
380	mov [cpu_vendor + 8 - OS_BASE], ecx	380	mov [cpu_vendor + 8 - OS_BASE], ecx
381		381
382	cmp eax, 1	382	cmp eax, 1
383	jl .end_cpuid	383	jl .end_cpuid
384	mov eax, 1	384	mov eax, 1
385	cpuid	385	cpuid
386	mov [cpu_sign - OS_BASE], eax	386	mov [cpu_sign - OS_BASE], eax
387	mov [cpu_info - OS_BASE], ebx	387	mov [cpu_info - OS_BASE], ebx
388	mov [cpu_caps - OS_BASE], edx	388	mov [cpu_caps - OS_BASE], edx
389	mov [cpu_caps + 4 - OS_BASE], ecx	389	mov [cpu_caps + 4 - OS_BASE], ecx
390		390
391	bt edx, CAPS_PAE	391	bt edx, CAPS_PAE
392	jnc @f	392	jnc @f
393	mov [cpu_phys_addr_width - OS_BASE], 36	393	mov [cpu_phys_addr_width - OS_BASE], 36
394	@@:	394	@@:
395	mov eax, 0x80000000	395	mov eax, 0x80000000
396	cpuid	396	cpuid
397	cmp eax, 0x80000008	397	cmp eax, 0x80000008
398	jb @f	398	jb @f
399	mov eax, 0x80000008	399	mov eax, 0x80000008
400	cpuid	400	cpuid
401	mov [cpu_phys_addr_width - OS_BASE], al	401	mov [cpu_phys_addr_width - OS_BASE], al
402	@@:	402	@@:
403		403
404	mov eax, [cpu_sign - OS_BASE]	404	mov eax, [cpu_sign - OS_BASE]
405	shr eax, 8	405	shr eax, 8
406	and eax, 0x0f	406	and eax, 0x0f
407	ret	407	ret
408	.end_cpuid:	408	.end_cpuid:
409	mov eax, [cpu_type]	409	mov eax, [cpu_type]
410	ret	410	ret
411	endp	411	endp
412		-
413	ACPI_HI_RSDP_WINDOW_START = 0x000E0000	-
414	ACPI_HI_RSDP_WINDOW_END = 0x00100000	412
415	ACPI_RSDP_CHECKSUM_LENGTH = 20	413	ACPI_RSDP_CHECKSUM_LENGTH = 20
416		414
417	proc acpi_locate_tables uses ebx esi edi	415	proc acpi_locate_tables uses ebx esi edi
418	mov ebx, [ebx + ACPI_RSDP.RsdtAddress]	416	mov ebx, [ebx + ACPI_RSDP.RsdtAddress]
419	mov [acpi_rsdt_base - OS_BASE], ebx	417	mov [acpi_rsdt_base - OS_BASE], ebx
420	mov eax, [ebx + ACPI_RSDT.Length]	418	mov eax, [ebx + ACPI_RSDT.Length]
421	mov [acpi_rsdt_size - OS_BASE], eax	419	mov [acpi_rsdt_size - OS_BASE], eax
422		420
423	mov esi, [acpi_rsdt_base - OS_BASE]	421	mov esi, [acpi_rsdt_base - OS_BASE]
424	mov ecx, [esi + ACPI_RSDT.Length]	422	mov ecx, [esi + ACPI_RSDT.Length]
425	lea edi, [esi + ecx]	423	lea edi, [esi + ecx]
426	add esi, sizeof.ACPI_TABLE	424	add esi, sizeof.ACPI_TABLE
427	movi ecx, 1	425	movi ecx, 1
428	.next_table:	426	.next_table:
429	cmp esi, edi	427	cmp esi, edi
430	jae .done	428	jae .done
431	lodsd	429	lodsd
432	cmp [eax+ACPI_TABLE.Signature], 'SSDT' ; skip DSDT if present	430	cmp [eax+ACPI_TABLE.Signature], 'SSDT' ; skip DSDT if present
433	jz .ssdt ; read it from FADT	431	jz .ssdt ; read it from FADT
434	cmp [eax+ACPI_TABLE.Signature], 'FACP' ; this is FADT	432	cmp [eax+ACPI_TABLE.Signature], 'FACP' ; this is FADT
435	jz .fadt	433	jz .fadt
436	cmp [eax+ACPI_TABLE.Signature], 'APIC' ; this is MADT	434	cmp [eax+ACPI_TABLE.Signature], 'APIC' ; this is MADT
437	jz .madt	435	jz .madt
438	cmp [eax+ACPI_TABLE.Signature], 'HPET'	436	cmp [eax+ACPI_TABLE.Signature], 'HPET'
439	jz .hpet	437	jz .hpet
440	jmp .next_table	438	jmp .next_table
441	.ssdt:	439	.ssdt:
442	mov [acpi_ssdt_base + ecx*4 - OS_BASE], eax	440	mov [acpi_ssdt_base + ecx*4 - OS_BASE], eax
443	mov eax, [eax+ACPI_TABLE.Length]	441	mov eax, [eax+ACPI_TABLE.Length]
444	mov [acpi_ssdt_size + ecx*4 - OS_BASE], eax	442	mov [acpi_ssdt_size + ecx*4 - OS_BASE], eax
445	inc ecx	443	inc ecx
446	jmp .next_table	444	jmp .next_table
447	.fadt:	445	.fadt:
448	mov [acpi_fadt_base - OS_BASE], eax	446	mov [acpi_fadt_base - OS_BASE], eax
449	cmp [eax + ACPI_FADT.DSDT], 0	447	cmp [eax + ACPI_FADT.DSDT], 0
450	jz @f	448	jz @f
451	mov edx, [eax + ACPI_FADT.DSDT]	449	mov edx, [eax + ACPI_FADT.DSDT]
452	mov [acpi_ssdt_base - OS_BASE], edx	450	mov [acpi_ssdt_base - OS_BASE], edx
453	mov edx, [edx + ACPI_TABLE.Length]	451	mov edx, [edx + ACPI_TABLE.Length]
454	mov [acpi_ssdt_size - OS_BASE], edx	452	mov [acpi_ssdt_size - OS_BASE], edx
455	@@:	453	@@:
456	mov eax, [eax + ACPI_TABLE.Length]	454	mov eax, [eax + ACPI_TABLE.Length]
457	mov [acpi_fadt_size - OS_BASE], eax	455	mov [acpi_fadt_size - OS_BASE], eax
458	jmp .next_table	456	jmp .next_table
459	.madt:	457	.madt:
460	mov [acpi_madt_base - OS_BASE], eax	458	mov [acpi_madt_base - OS_BASE], eax
461	mov eax, [eax + ACPI_TABLE.Length]	459	mov eax, [eax + ACPI_TABLE.Length]
462	mov [acpi_madt_size - OS_BASE], eax	460	mov [acpi_madt_size - OS_BASE], eax
463	jmp .next_table	461	jmp .next_table
464	.hpet:	462	.hpet:
465	mov [acpi_hpet_base - OS_BASE], eax	463	mov [acpi_hpet_base - OS_BASE], eax
466	mov eax, [eax + ACPI_TABLE.Length]	464	mov eax, [eax + ACPI_TABLE.Length]
467	mov [acpi_hpet_size - OS_BASE], eax	465	mov [acpi_hpet_size - OS_BASE], eax
468	jmp .next_table	466	jmp .next_table
469	.done:	467	.done:
470	mov [acpi_ssdt_cnt - OS_BASE], ecx	468	mov [acpi_ssdt_cnt - OS_BASE], ecx
471	ret	469	ret
472	endp	470	endp
473		471
474	acpi_locate:	472	acpi_locate:
475	push ebx	473	push ebx
476	push edi	474	push edi
477		-
478	if defined UEFI	-
479	; UEFI loader knows where RSDP is	475
480	mov ebx, [BOOT_LO.acpi_rsdp]	476	mov ebx, [BOOT_LO.acpi_rsdp]
481	test ebx, ebx	477	test ebx, ebx
482	jz .done	478	jz .done
-		479	mov edi, ebx
483	call .check	480	call .check
484	else	-
485	movzx ebx, word [0x40E]	-
486	shl ebx, 4	-
487	lea ecx, [ebx+1024]	-
488	call .check	-
489		-
490	test ebx, ebx	-
491	jz @F	-
492	jmp .done	-
493		-
494	@@:	-
495	mov ebx, ACPI_HI_RSDP_WINDOW_START	-
496	mov edi, ACPI_HI_RSDP_WINDOW_END	-
497	call .check	-
498	end if	-
499	.done:	481	.done:

Subversion Repositories Kolibri OS

(root)/kernel/trunk/init.inc @ 7736 – Rev 9899 → 9958