;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2024. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
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