Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; 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