WebSVN – Kolibri OS – Diff – /kernel/trunk/core/mtrr.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9715 $
 
; Initializes MTRRs.
proc init_mtrr
 
        cmp     [BOOT.mtrr], byte 2
        je      .exit
 
        bt      [cpu_caps], CAPS_MTRR
        jnc     .exit
 
        call    mtrr_reconfigure
        stdcall set_mtrr, [LFBAddress], 0x1000000, MEM_WC
 
.exit:
        ret
endp
 
; Helper procedure for mtrr_reconfigure and set_mtrr,
; called before changes in MTRRs.
; 1. disable and flush caches
; 2. clear PGE bit in cr4
; 3. flush TLB
; 4. disable mtrr
 
proc mtrr_begin_change
        mov     eax, cr0
        or      eax, 0x60000000 ;disable caching
        mov     cr0, eax
        wbinvd                  ;invalidate cache
 
        bt      [cpu_caps], CAPS_PGE
        jnc     .cr3_flush
 
        mov     eax, cr4
        btr     eax, 7          ;clear cr4.PGE
        mov     cr4, eax        ;flush TLB
        jmp     @F              ;skip extra serialization
 
.cr3_flush:
        mov     eax, cr3
        mov     cr3, eax        ;flush TLB
@@:
        mov     ecx, MSR_MTRR_DEF_TYPE
        rdmsr
        btr     eax, 11         ;clear enable flag
        wrmsr                   ;disable mtrr
        ret
endp
 
; Helper procedure for mtrr_reconfigure and set_mtrr,
; called after changes in MTRRs.
; 1. enable mtrr
; 2. flush all caches
; 3. flush TLB
; 4. restore cr4.PGE flag, if required
 
proc mtrr_end_change
        mov     ecx, MSR_MTRR_DEF_TYPE
        rdmsr
        or      ah, 8           ; enable variable-ranges MTRR
        and     al, 0xF0        ; default memtype = UC
        wrmsr
 
        wbinvd                  ;again invalidate
        mov     eax, cr0
        and     eax, not 0x60000000
        mov     cr0, eax        ; enable caching
 
        mov     eax, cr3
        mov     cr3, eax        ;flush tlb
 
        bt      [cpu_caps], CAPS_PGE
        jnc     @F
 
        mov     eax, cr4
        bts     eax, 7          ;set cr4.PGE flag
        mov     cr4, eax
@@:
        ret
endp
 
; Some limits to number of structures located in the stack.
MAX_USEFUL_MTRRS = 16
MAX_RANGES = 16
 
; mtrr_reconfigure keeps a list of MEM_WB ranges.
; This structure describes one item in the list.
struct mtrr_range
next            dd      ?       ; next item
start           dq      ?       ; first byte
length          dq      ?       ; length in bytes
ends
 
uglobal
align 4
num_variable_mtrrs      dd      0       ; number of variable-range MTRRs
endg
 
; Helper procedure for MTRR initialization.
; Takes MTRR configured by BIOS and tries to recongifure them
; in order to allow non-UC data at top of 4G memory.
; Example: if low part of physical memory is 3.5G = 0xE0000000 bytes wide,
; BIOS can configure two MTRRs so that the first MTRR describes [0, 4G) as WB
; and the second MTRR describes [3.5G, 4G) as UC;
; WB+UC=UC, so the resulting memory map would be as needed,
; but in this configuration our attempts to map LFB at (say) 0xE8000000 as WC
; would be ignored, WB+UC+WC is still UC.
; So we must keep top of 4G memory not covered by MTRRs,
; using three WB MTRRs [0,2G) + [2G,3G) + [3G,3.5G),
; this gives the same memory map, but allows to add further entries.
; See mtrrtest.asm for detailed input/output from real hardware+BIOS.
proc mtrr_reconfigure
        push    ebp     ; we're called from init_LFB, and it feels hurt when ebp is destroyed
; 1. Prepare local variables.
; 1a. Create list of MAX_RANGES free (aka not yet allocated) ranges.
        xor     eax, eax
        lea     ecx, [eax + MAX_RANGES]
.init_ranges:
        sub     esp, sizeof.mtrr_range - 4
        push    eax
        mov     eax, esp
        dec     ecx
        jnz     .init_ranges
        mov     eax, esp
; 1b. Fill individual local variables.
        xor     edx, edx
        sub     esp, MAX_USEFUL_MTRRS * 16      ; .mtrrs
        push    edx             ; .mtrrs_end
        push    edx             ; .num_used_mtrrs
        push    eax             ; .first_free_range
        push    edx             ; .first_range: no ranges yet
        mov     cl, [cpu_phys_addr_width]
        or      eax, -1
        shl     eax, cl ; note: this uses cl&31 = cl-32, not the entire cl
        push    eax     ; .phys_reserved_mask
virtual at esp
.phys_reserved_mask     dd      ?
.first_range            dd      ?
.first_free_range       dd      ?
.num_used_mtrrs         dd      ?
.mtrrs_end              dd      ?
.mtrrs          rq      MAX_USEFUL_MTRRS * 2
.local_vars_size = $ - esp
end virtual
 
; 2. Get the number of variable-range MTRRs from MTRRCAP register.
; Abort if zero.
        mov     ecx, 0xFE
        rdmsr
        test    al, al
        jz      .abort
        mov     byte [num_variable_mtrrs], al
; 3. Validate MTRR_DEF_TYPE register.
        mov     ecx, 0x2FF
        rdmsr
; If BIOS has not initialized variable-range MTRRs, fallback to step 7.
        test    ah, 8
        jz      .fill_ranges_from_memory_map
; If the default memory type (not covered by MTRRs) is not UC,
; then probably BIOS did something strange, so it is better to exit immediately
; hoping for the best.
        cmp     al, MEM_UC
        jnz     .abort
; 4. Validate all variable-range MTRRs
; and copy configured MTRRs to the local array [.mtrrs].
; 4a. Prepare for the loop over existing variable-range MTRRs.
        mov     ecx, 0x200
        lea     edi, [.mtrrs]
.get_used_mtrrs_loop:
; 4b. For every MTRR, read PHYSBASEn and PHYSMASKn.
; In PHYSBASEn, clear upper bits and copy to ebp:ebx.
        rdmsr
        or      edx, [.phys_reserved_mask]
        xor     edx, [.phys_reserved_mask]
        mov     ebp, edx
        mov     ebx, eax
        inc     ecx
; If PHYSMASKn is not active, ignore this MTRR.
        rdmsr
        inc     ecx
        test    ah, 8
        jz      .get_used_mtrrs_next
; 4c. For every active MTRR, check that number of local entries is not too large.
        inc     [.num_used_mtrrs]
        cmp     [.num_used_mtrrs], MAX_USEFUL_MTRRS
        ja      .abort
; 4d. For every active MTRR, store PHYSBASEn with upper bits cleared.
; This contains the MTRR base and the memory type in low byte.
        mov     [edi], ebx
        mov     [edi+4], ebp
; 4e. For every active MTRR, check that the range is continuous:
; PHYSMASKn with upper bits set must be negated power of two, and
; low bits of PHYSBASEn must be zeroes:
; PHYSMASKn = 1...10...0,
; PHYSBASEn = x...x0...0,
; this defines a continuous range from x...x0...0 to x...x1...1,
; length = 10...0 = negated PHYSMASKn.
; Store length in the local array.
        and     eax, not 0xFFF
        or      edx, [.phys_reserved_mask]
        mov     dword [edi+8], 0
        mov     dword [edi+12], 0
        sub     [edi+8], eax
        sbb     [edi+12], edx
; (x and -x) is the maximum power of two that divides x.
; Condition for powers of two: (x and -x) equals x.
        and     eax, [edi+8]
        and     edx, [edi+12]
        cmp     eax, [edi+8]
        jnz     .abort
        cmp     edx, [edi+12]
        jnz     .abort
        sub     eax, 1
        sbb     edx, 0
        and     eax, not 0xFFF
        and     eax, ebx
        jnz     .abort
        and     edx, ebp
        jnz     .abort
; 4f. For every active MTRR, validate memory type: it must be either WB or UC.
        add     edi, 16
        cmp     bl, MEM_UC
        jz      .get_used_mtrrs_next
        cmp     bl, MEM_WB
        jnz     .abort
.get_used_mtrrs_next:
; 4g. Repeat the loop at 4b-4f for all [num_variable_mtrrs] entries.
        mov     eax, [num_variable_mtrrs]
        lea     eax, [0x200+eax*2]
        cmp     ecx, eax
        jb      .get_used_mtrrs_loop
; 4h. If no active MTRRs were detected, fallback to step 7.
        cmp     [.num_used_mtrrs], 0
        jz      .fill_ranges_from_memory_map
        mov     [.mtrrs_end], edi
; 5. Generate sorted list of ranges marked as WB.
; 5a. Prepare for the loop over configured MTRRs filled at step 4.
        lea     ecx, [.mtrrs]
.fill_wb_ranges:
; 5b. Ignore non-WB MTRRs.
        mov     ebx, [ecx]
        cmp     bl, MEM_WB
        jnz     .next_wb_range
        mov     ebp, [ecx+4]
        and     ebx, not 0xFFF  ; clear memory type and reserved bits
; ebp:ebx = start of the range described by the current MTRR.
; 5c. Find the first existing range containing a point greater than ebp:ebx.
        lea     esi, [.first_range]
.find_range_wb:
; If there is no next range or start of the next range is greater than ebp:ebx,
; exit the loop to 5d.
        mov     edi, [esi]
        test    edi, edi
        jz      .found_place_wb
        mov     eax, ebx
        mov     edx, ebp
        sub     eax, dword [edi + mtrr_range.start]
        sbb     edx, dword [edi + mtrr_range.start+4]
        jb      .found_place_wb
; Otherwise, if end of the next range is greater than or equal to ebp:ebx,
; exit the loop to 5e.
        mov     esi, edi
        sub     eax, dword [edi + mtrr_range.length]
        sbb     edx, dword [edi + mtrr_range.length+4]
        jb      .expand_wb
        or      eax, edx
        jnz     .find_range_wb
        jmp     .expand_wb
.found_place_wb:
; 5d. ebp:ebx is not within any existing range.
; Insert a new range between esi and edi.
; (Later, during 5e, it can be merged with the following ranges.)
        mov     eax, [.first_free_range]
        test    eax, eax
        jz      .abort
        mov     [esi], eax
        mov     edx, [eax + mtrr_range.next]
        mov     [.first_free_range], edx
        mov     dword [eax + mtrr_range.start], ebx
        mov     dword [eax + mtrr_range.start+4], ebp
; Don't fill [eax+mtrr_range.next] and [eax+mtrr_range.length] yet,
; they will be calculated including merges at step 5e.
        mov     esi, edi
        mov     edi, eax
.expand_wb:
; 5e. The range at edi contains ebp:ebx, and esi points to the first range
; to be checked for merge: esi=edi if ebp:ebx was found in an existing range,
; esi is next after edi if a new range with ebp:ebx was created.
; Merge it with following ranges while start of the next range is not greater
; than the end of the new range.
        add     ebx, [ecx+8]
        adc     ebp, [ecx+12]
; ebp:ebx = end of the range described by the current MTRR.
.expand_wb_loop:
; If there is no next range or start of the next range is greater than ebp:ebx,
; exit the loop to 5g.
        test    esi, esi
        jz      .expand_wb_done
        mov     eax, ebx
        mov     edx, ebp
        sub     eax, dword [esi + mtrr_range.start]
        sbb     edx, dword [esi + mtrr_range.start+4]
        jb      .expand_wb_done
; Otherwise, if end of the next range is greater than or equal to ebp:ebx,
; exit the loop to 5f.
        sub     eax, dword [esi + mtrr_range.length]
        sbb     edx, dword [esi + mtrr_range.length+4]
        jb      .expand_wb_last
; Otherwise, the current range is completely within the new range.
; Free it and continue the loop.
        mov     edx, [esi + mtrr_range.next]
        cmp     esi, edi
        jz      @f
        mov     eax, [.first_free_range]
        mov     [esi + mtrr_range.next], eax
        mov     [.first_free_range], esi
@@:
        mov     esi, edx
        jmp     .expand_wb_loop
.expand_wb_last:
; 5f. Start of the new range is inside range described by esi,
; end of the new range is inside range described by edi.
; If esi is equal to edi, the new range is completely within
; an existing range, so proceed to the next range.
        cmp     esi, edi
        jz      .next_wb_range
; Otherwise, set end of interval at esi to end of interval at edi
; and free range described by edi.
        mov     ebx, dword [esi + mtrr_range.start]
        mov     ebp, dword [esi + mtrr_range.start+4]
        add     ebx, dword [esi + mtrr_range.length]
        adc     ebp, dword [esi + mtrr_range.length+4]
        mov     edx, [esi + mtrr_range.next]
        mov     eax, [.first_free_range]
        mov     [esi + mtrr_range.next], eax
        mov     [.first_free_range], esi
        mov     esi, edx
.expand_wb_done:
; 5g. We have found the next range (maybe 0) after merging and
; the new end of range (maybe ebp:ebx from the new range
; or end of another existing interval calculated at step 5f).
; Write them to range at edi.
        mov     [edi + mtrr_range.next], esi
        sub     ebx, dword [edi + mtrr_range.start]
        sbb     ebp, dword [edi + mtrr_range.start+4]
        mov     dword [edi + mtrr_range.length], ebx
        mov     dword [edi + mtrr_range.length+4], ebp
.next_wb_range:
; 5h. Continue the loop 5b-5g over all configured MTRRs.
        add     ecx, 16
        cmp     ecx, [.mtrrs_end]
        jb      .fill_wb_ranges
; 6. Exclude all ranges marked as UC.
; 6a. Prepare for the loop over configured MTRRs filled at step 4.
        lea     ecx, [.mtrrs]
.fill_uc_ranges:
; 6b. Ignore non-UC MTRRs.
        mov     ebx, [ecx]
        cmp     bl, MEM_UC
        jnz     .next_uc_range
        mov     ebp, [ecx+4]
        and     ebx, not 0xFFF  ; clear memory type and reserved bits
; ebp:ebx = start of the range described by the current MTRR.
        lea     esi, [.first_range]
; 6c. Find the first existing range containing a point greater than ebp:ebx.
.find_range_uc:
; If there is no next range, ignore this MTRR,
; exit the loop and continue to next MTRR.
        mov     edi, [esi]
        test    edi, edi
        jz      .next_uc_range
; If start of the next range is greater than or equal to ebp:ebx,
; exit the loop to 6e.
        mov     eax, dword [edi + mtrr_range.start]
        mov     edx, dword [edi + mtrr_range.start+4]
        sub     eax, ebx
        sbb     edx, ebp
        jnb     .truncate_uc
; Otherwise, continue the loop if end of the next range is less than ebp:ebx,
; exit the loop to 6d otherwise.
        mov     esi, edi
        add     eax, dword [edi + mtrr_range.length]
        adc     edx, dword [edi + mtrr_range.length+4]
        jnb     .find_range_uc
; 6d. ebp:ebx is inside (or at end of) an existing range.
; Split the range. (The second range, maybe containing completely within UC-range,
; maybe of zero length, can be removed at step 6e, if needed.)
        mov     edi, [.first_free_range]
        test    edi, edi
        jz      .abort
        mov     dword [edi + mtrr_range.start], ebx
        mov     dword [edi + mtrr_range.start+4], ebp
        mov     dword [edi + mtrr_range.length], eax
        mov     dword [edi + mtrr_range.length+4], edx
        mov     eax, [edi + mtrr_range.next]
        mov     [.first_free_range], eax
        mov     eax, [esi + mtrr_range.next]
        mov     [edi + mtrr_range.next], eax
; don't change [esi+mtrr_range.next] yet, it will be filled at step 6e
        mov     eax, ebx
        mov     edx, ebp
        sub     eax, dword [esi + mtrr_range.start]
        sbb     edx, dword [esi + mtrr_range.start+4]
        mov     dword [esi + mtrr_range.length], eax
        mov     dword [esi + mtrr_range.length+4], edx
.truncate_uc:
; 6e. edi is the first range after ebp:ebx, check it and next ranges
; for intersection with the new range, truncate heads.
        add     ebx, [ecx+8]
        adc     ebp, [ecx+12]
; ebp:ebx = end of the range described by the current MTRR.
.truncate_uc_loop:
; If start of the next range is greater than ebp:ebx,
; exit the loop to 6g.
        mov     eax, ebx
        mov     edx, ebp
        sub     eax, dword [edi + mtrr_range.start]
        sbb     edx, dword [edi + mtrr_range.start+4]
        jb      .truncate_uc_done
; Otherwise, if end of the next range is greater than ebp:ebx,
; exit the loop to 6f.
        sub     eax, dword [edi + mtrr_range.length]
        sbb     edx, dword [edi + mtrr_range.length+4]
        jb      .truncate_uc_last
; Otherwise, the current range is completely within the new range.
; Free it and continue the loop if there is a next range.
; If that was a last range, exit the loop to 6g.
        mov     edx, [edi + mtrr_range.next]
        mov     eax, [.first_free_range]
        mov     [.first_free_range], edi
        mov     [edi + mtrr_range.next], eax
        mov     edi, edx
        test    edi, edi
        jnz     .truncate_uc_loop
        jmp     .truncate_uc_done
.truncate_uc_last:
; 6f. The range at edi partially intersects with the UC-range described by MTRR.
; Truncate it from the head.
        mov     dword [edi + mtrr_range.start], ebx
        mov     dword [edi + mtrr_range.start+4], ebp
        neg     eax
        adc     edx, 0
        neg     edx
        mov     dword [edi + mtrr_range.length], eax
        mov     dword [edi + mtrr_range.length+4], edx
.truncate_uc_done:
; 6g. We have found the next range (maybe 0) after intersection.
; Write it to [esi+mtrr_range.next].
        mov     [esi + mtrr_range.next], edi
.next_uc_range:
; 6h. Continue the loop 6b-6g over all configured MTRRs.
        add     ecx, 16
        cmp     ecx, [.mtrrs_end]
        jb      .fill_uc_ranges
; Sanity check: if there are no ranges after steps 5-6,
; fallback to step 7. Otherwise, go to 8.
        cmp     [.first_range], 0
        jnz     .ranges_ok
.fill_ranges_from_memory_map:
; 7. BIOS has not configured variable-range MTRRs.
; Create one range from 0 to [MEM_AMOUNT].
        mov     eax, [.first_free_range]
        mov     edx, [eax + mtrr_range.next]
        mov     [.first_free_range], edx
        mov     [.first_range], eax
        xor     edx, edx
        mov     [eax + mtrr_range.next], edx
        mov     dword [eax + mtrr_range.start], edx
        mov     dword [eax + mtrr_range.start+4], edx
        mov     ecx, [MEM_AMOUNT]
        mov     dword [eax + mtrr_range.length], ecx
        mov     dword [eax + mtrr_range.length+4], edx
.ranges_ok:
; 8. We have calculated list of WB-ranges.
; Now we should calculate a list of MTRRs so that
; * every MTRR describes a range with length = power of 2 and start that is aligned,
; * every MTRR can be WB or UC
; * (sum of all WB ranges) minus (sum of all UC ranges) equals the calculated list
; * top of 4G memory must not be covered by any ranges
; Example: range [0,0xBC000000) can be converted to
; [0,0x80000000)+[0x80000000,0xC0000000)-[0xBC000000,0xC0000000)
; WB            +WB                     -UC
; but not to [0,0x100000000)-[0xC0000000,0x100000000)-[0xBC000000,0xC0000000).
; 8a. Check that list of ranges is [0,something) plus, optionally, [4G,something).
; This holds in practice (see mtrrtest.asm for real-life examples)
; and significantly simplifies the code: ranges are independent, start of range
; is almost always aligned (the only exception >4G upper memory can be easily covered),
; there is no need to consider adding holes before start of range, only
; append them to end of range.
        xor     eax, eax
        mov     edi, [.first_range]
        cmp     dword [edi + mtrr_range.start], eax
        jnz     .abort
        cmp     dword [edi + mtrr_range.start+4], eax
        jnz     .abort
        cmp     dword [edi + mtrr_range.length+4], eax
        jnz     .abort
        mov     edx, [edi + mtrr_range.next]
        test    edx, edx
        jz      @f
        cmp     dword [edx + mtrr_range.start], eax
        jnz     .abort
        cmp     dword [edx + mtrr_range.start+4], 1
        jnz     .abort
        cmp     [edx + mtrr_range.next], eax
        jnz     .abort
@@:
; 8b. Initialize: no MTRRs filled.
        mov     [.num_used_mtrrs], eax
        lea     esi, [.mtrrs]
.range2mtrr_loop:
; 8c. If we are dealing with upper-memory range (after 4G)
; with length > start, create one WB MTRR with [start,2*start),
; reset start to 2*start and return to this step.
; Example: [4G,24G) -> [4G,8G) {returning} + [8G,16G) {returning}
; + [16G,24G) {advancing to ?}.
        mov     eax, dword [edi + mtrr_range.length+4]
        test    eax, eax
        jz      .less4G
        mov     edx, dword [edi + mtrr_range.start+4]
        cmp     eax, edx
        jb      .start_aligned
        inc     [.num_used_mtrrs]
        cmp     [.num_used_mtrrs], MAX_USEFUL_MTRRS
        ja      .abort
        mov     dword [esi], MEM_WB
        mov     dword [esi+4], edx
        mov     dword [esi+8], 0
        mov     dword [esi+12], edx
        add     esi, 16
        add     dword [edi + mtrr_range.start+4], edx
        sub     dword [edi + mtrr_range.length+4], edx
        jnz     .range2mtrr_loop
        cmp     dword [edi + mtrr_range.length], 0
        jz      .range2mtrr_next
.less4G:
; 8d. If we are dealing with low-memory range (before 4G)
; and appending a maximal-size hole would create a range covering top of 4G,
; create a maximal-size WB range and return to this step.
; Example: for [0,0xBC000000) the following steps would consider
; variants [0,0x80000000)+(another range to be splitted) and
; [0,0x100000000)-(another range to be splitted); we forbid the last variant,
; so the first variant must be used.
        bsr     ecx, dword [edi + mtrr_range.length]
        xor     edx, edx
        inc     edx
        shl     edx, cl
        lea     eax, [edx*2]
        add     eax, dword [edi + mtrr_range.start]
        jnz     .start_aligned
        inc     [.num_used_mtrrs]
        cmp     [.num_used_mtrrs], MAX_USEFUL_MTRRS
        ja      .abort
        mov     eax, dword [edi + mtrr_range.start]
        mov     dword [esi], eax
        or      dword [esi], MEM_WB
        mov     dword [esi+4], 0
        mov     dword [esi+8], edx
        mov     dword [esi+12], 0
        add     esi, 16
        add     dword [edi + mtrr_range.start], edx
        sub     dword [edi + mtrr_range.length], edx
        jnz     .less4G
        jmp     .range2mtrr_next
.start_aligned:
; Start is aligned for any allowed length, maximum-size hole is allowed.
; Select the best MTRR configuration for one range.
; length=...101101
; Without hole at the end, we need one WB MTRR for every 1-bit in length:
; length=...100000 + ...001000 + ...000100 + ...000001
; We can also append one hole at the end so that one 0-bit (selected by us)
; becomes 1 and all lower bits become 0 for WB-range:
; length=...110000 - (...00010 + ...00001)
; In this way, we need one WB MTRR for every 1-bit higher than the selected bit,
; one WB MTRR for the selected bit, one UC MTRR for every 0-bit between
; the selected bit and lowest 1-bit (they become 1-bits after negation)
; and one UC MTRR for lowest 1-bit.
; So we need to select 0-bit with the maximal difference
; (number of 0-bits) - (number of 1-bits) between selected and lowest 1-bit,
; this equals the gain from using a hole. If the difference is negative for
; all 0-bits, don't append hole.
; Note that lowest 1-bit is not included when counting, but selected 0-bit is.
; 8e. Find the optimal bit position for hole.
; eax = current difference, ebx = best difference,
; ecx = hole bit position, edx = current bit position.
        xor     eax, eax
        xor     ebx, ebx
        xor     ecx, ecx
        bsf     edx, dword [edi + mtrr_range.length]
        jnz     @f
        bsf     edx, dword [edi + mtrr_range.length+4]
        add     edx, 32
@@:
        push    edx     ; save position of lowest 1-bit for step 8f
.calc_stat:
        inc     edx
        cmp     edx, 64
        jae     .stat_done
        inc     eax     ; increment difference in hope for 1-bit
; Note: bt conveniently works with both .length and .length+4,
; depending on whether edx>=32.
        bt      dword [edi + mtrr_range.length], edx
        jc      .calc_stat
        dec     eax     ; hope was wrong, decrement difference to correct 'inc'
        dec     eax     ; and again, now getting the real difference
        cmp     eax, ebx
        jle     .calc_stat
        mov     ebx, eax
        mov     ecx, edx
        jmp     .calc_stat
.stat_done:
; 8f. If we decided to create a hole, flip all bits between lowest and selected.
        pop     edx     ; restore position of lowest 1-bit saved at step 8e
        test    ecx, ecx
        jz      .fill_hi_init
@@:
        inc     edx
        cmp     edx, ecx
        ja      .fill_hi_init
        btc     dword [edi + mtrr_range.length], edx
        jmp     @b
.fill_hi_init:
; 8g. Create MTRR ranges corresponding to upper 32 bits.
        sub     ecx, 32
.fill_hi_loop:
        bsr     edx, dword [edi + mtrr_range.length+4]
        jz      .fill_hi_done
        inc     [.num_used_mtrrs]
        cmp     [.num_used_mtrrs], MAX_USEFUL_MTRRS
        ja      .abort
        mov     eax, dword [edi + mtrr_range.start]
        mov     [esi], eax
        mov     eax, dword [edi + mtrr_range.start+4]
        mov     [esi+4], eax
        xor     eax, eax
        mov     [esi+8], eax
        bts     eax, edx
        mov     [esi+12], eax
        cmp     edx, ecx
        jl      .fill_hi_uc
        or      dword [esi], MEM_WB
        add     dword [edi + mtrr_range.start+4], eax
        jmp     @f
.fill_hi_uc:
        sub     dword [esi+4], eax
        sub     dword [edi + mtrr_range.start+4], eax
@@:
        add     esi, 16
        sub     dword [edi + mtrr_range.length], eax
        jmp     .fill_hi_loop
.fill_hi_done:
; 8h. Create MTRR ranges corresponding to lower 32 bits.
        add     ecx, 32
.fill_lo_loop:
        bsr     edx, dword [edi+mtrr_range.length]
        jz      .range2mtrr_next
        inc     [.num_used_mtrrs]
        cmp     [.num_used_mtrrs], MAX_USEFUL_MTRRS
        ja      .abort
        mov     eax, dword [edi + mtrr_range.start]
        mov     [esi], eax
        mov     eax, dword [edi + mtrr_range.start+4]
        mov     [esi+4], eax
        xor     eax, eax
        mov     [esi+12], eax
        bts     eax, edx
        mov     [esi+8], eax
        cmp     edx, ecx
        jl      .fill_lo_uc
        or      dword [esi], MEM_WB
        add     dword [edi + mtrr_range.start], eax
        jmp     @f
.fill_lo_uc:
        sub     dword [esi], eax
        sub     dword [edi + mtrr_range.start], eax
@@:
        add     esi, 16
        sub     dword [edi + mtrr_range.length], eax
        jmp     .fill_lo_loop
.range2mtrr_next:
; 8i. Repeat the loop at 8c-8h for all ranges.
        mov     edi, [edi + mtrr_range.next]
        test    edi, edi
        jnz     .range2mtrr_loop
; 9. We have calculated needed MTRRs, now setup them in the CPU.
; 9a. Abort if number of MTRRs is too large.
        mov     eax, [num_variable_mtrrs]
        cmp     [.num_used_mtrrs], eax
        ja      .abort
 
; 9b. Prepare for changes.
        call    mtrr_begin_change
 
; 9c. Prepare for loop over MTRRs.
        lea     esi, [.mtrrs]
        mov     ecx, 0x200
@@:
; 9d. For every MTRR, copy PHYSBASEn as is: step 8 has configured
; start value and type bits as needed.
        mov     eax, [esi]
        mov     edx, [esi+4]
        wrmsr
        inc     ecx
; 9e. For every MTRR, calculate PHYSMASKn = -(length) or 0x800
; with upper bits cleared, 0x800 = MTRR is valid.
        xor     eax, eax
        xor     edx, edx
        sub     eax, [esi+8]
        sbb     edx, [esi+12]
        or      eax, 0x800
        or      edx, [.phys_reserved_mask]
        xor     edx, [.phys_reserved_mask]
        wrmsr
        inc     ecx
; 9f. Continue steps 9d and 9e for all MTRRs calculated at step 8.
        add     esi, 16
        dec     [.num_used_mtrrs]
        jnz     @b
; 9g. Zero other MTRRs.
        xor     eax, eax
        xor     edx, edx
        mov     ebx, [num_variable_mtrrs]
        lea     ebx, [0x200+ebx*2]
@@:
        cmp     ecx, ebx
        jae     @f
        wrmsr
        inc     ecx
        wrmsr
        inc     ecx
        jmp     @b
@@:
 
; 9i. Check PAT support and reprogram PAT_MASR for write combining memory
        bt      [cpu_caps], CAPS_PAT
        jnc     @F
 
        mov     ecx, MSR_CR_PAT
        mov     eax, PAT_VALUE  ;UC UCM WC WB
        mov     edx, eax
        wrmsr
@@:
 
; 9j. Changes are done.
        call    mtrr_end_change
 
.abort:
        add     esp, .local_vars_size + MAX_RANGES * sizeof.mtrr_range
        pop     ebp
        ret
endp
 
; Allocate&set one MTRR for given range.
; size must be power of 2 that divides base.
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword
; find unused register
        mov     ecx, 0x201
.scan:
        mov     eax, [num_variable_mtrrs]
        lea     eax, [0x200+eax*2]
        cmp     ecx, eax
        jae     .ret
        rdmsr
        dec     ecx
        test    ah, 8
        jz      .found
        rdmsr
        test    edx, edx
        jnz     @f
        and     eax, not 0xFFF  ; clear reserved bits
        cmp     eax, [base]
        jz      .ret
@@:
        add     ecx, 3
        jmp     .scan
; no free registers, ignore the call
.ret:
        ret
.found:
; found, write values
        push    ecx
        call    mtrr_begin_change
        pop     ecx
        xor     edx, edx
        mov     eax, [base]
        or      eax, [mem_type]
        wrmsr
 
        mov     al, [cpu_phys_addr_width]
        xor     edx, edx
        bts     edx, eax
        xor     eax, eax
        sub     eax, [size]
        sbb     edx, 0
        or      eax, 0x800
        inc     ecx
        wrmsr
        call    mtrr_end_change
        ret
endp
 
; Helper procedure for mtrr_validate.
; Calculates memory type for given address according to variable-range MTRRs.
; Assumes that MTRRs are enabled.
; in: ebx = 32-bit physical address
; out: eax = memory type for ebx
proc mtrr_get_real_type
; 1. Initialize: we have not yet found any MTRRs covering ebx.
        push    0
        mov     ecx, 0x201
.mtrr_loop:
; 2. For every MTRR, check whether it is valid; if not, continue to the next MTRR.
        rdmsr
        dec     ecx
        test    ah, 8
        jz      .next
; 3. For every valid MTRR, check whether (ebx and PHYSMASKn) == PHYSBASEn,
; excluding low 12 bits.
        and     eax, ebx
        push    eax
        rdmsr
        test    edx, edx
        pop     edx
        jnz     .next
        xor     edx, eax
        and     edx, not 0xFFF
        jnz     .next
; 4. If so, set the bit corresponding to memory type defined by this MTRR.
        and     eax, 7
        bts     [esp], eax
.next:
; 5. Continue loop at 2-4 for all variable-range MTRRs.
        add     ecx, 3
        mov     eax, [num_variable_mtrrs]
        lea     eax, [0x200+eax*2]
        cmp     ecx, eax
        jb      .mtrr_loop
; 6. If no MTRRs cover address in ebx, use default MTRR type from MTRR_DEF_CAP.
        pop     edx
        test    edx, edx
        jz      .default
; 7. Find&clear 1-bit in edx.
        bsf     eax, edx
        btr     edx, eax
; 8. If there was only one 1-bit, then all MTRRs are consistent, return that bit.
        test    edx, edx
        jz      .nothing
; Otherwise, return MEM_UC (e.g. WB+UC is UC).
        xor     eax, eax
.nothing:
        ret
.default:
        mov     ecx, 0x2FF
        rdmsr
        movzx   eax, al
        ret
endp
 
; If MTRRs are configured improperly, this is not obvious to the user;
; everything works, but the performance can be horrible.
; Try to detect this and let the user know that the low performance
; is caused by some problem and is not a global property of the system.
; Let's hope he would report it to developers...
proc mtrr_validate
; 1. If MTRRs are not supported, they cannot be configured improperly.
; Note: VirtualBox claims MTRR support in cpuid, but emulates MTRRCAP=0,
; which is efficiently equivalent to absent MTRRs.
; So check [num_variable_mtrrs] instead of CAPS_MTRR in [cpu_caps].
        cmp     [num_variable_mtrrs], 0
        jz      .exit
; 2. If variable-range MTRRs are not configured, this is a problem.
        mov     ecx, 0x2FF
        rdmsr
        test    ah, 8
        jz      .fail
; 3. Get the memory type for address somewhere inside working memory.
; It must be write-back.
        mov     ebx, 0x27FFFF
        call    mtrr_get_real_type
        cmp     al, MEM_WB
        jnz     .fail
; 4. If we're using a mode with LFB,
; get the memory type for last pixel of the framebuffer.
; It must be write-combined.
        test    word [SCR_MODE], 0x4000
        jz      .exit
        mov     eax, [_display.lfb_pitch]
        mul     [_display.height]
        dec     eax
; LFB is mapped to virtual address LFB_BASE,
; it uses global pages if supported by CPU.
        mov     ebx, [sys_proc + PROC.pdt_0 + (LFB_BASE shr 20)]
        test    ebx, PDE_LARGE
        jnz     @f
        mov     ebx, [page_tabs+(LFB_BASE shr 10)]
@@:
        and     ebx, not 0xFFF
        add     ebx, eax
        call    mtrr_get_real_type
        cmp     al, MEM_WC
        jz      .exit
; 5. The check at step 4 fails on Bochs:
; Bochs BIOS configures MTRRs in a strange way not respecting [cpu_phys_addr_width],
; so mtrr_reconfigure avoids to touch anything.
; However, Bochs core ignores MTRRs (keeping them only for rdmsr/wrmsr),
; so we don't care about proper setting for Bochs.
; Use northbridge PCI id to detect Bochs: it emulates either i440fx or i430fx
; depending on configuration file.
        mov     eax, [pcidev_list.fd]
        cmp     eax, pcidev_list        ; sanity check: fail if no PCI devices
        jz      .fail
        cmp     [eax + PCIDEV.vendor_device_id], 0x12378086
        jz      .exit
        cmp     [eax + PCIDEV.vendor_device_id], 0x01228086
        jnz     .fail
.exit:
        ret
.fail:
        mov     ebx, mtrr_user_message
        mov     ebp, notifyapp
        call    fs_execute_from_sysdir_param
        ret
endp

Rev 7132	Rev 9715
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. 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: 7132 $	8	$Revision: 9715 $
9		9
10	; Initializes MTRRs.	10	; Initializes MTRRs.
11	proc init_mtrr	11	proc init_mtrr
12		12
13	cmp [BOOT.mtrr], byte 2	13	cmp [BOOT.mtrr], byte 2
14	je .exit	14	je .exit
15		15
16	bt [cpu_caps], CAPS_MTRR	16	bt [cpu_caps], CAPS_MTRR
17	jnc .exit	17	jnc .exit
18		18
19	call mtrr_reconfigure	19	call mtrr_reconfigure
20	stdcall set_mtrr, [LFBAddress], 0x1000000, MEM_WC	20	stdcall set_mtrr, [LFBAddress], 0x1000000, MEM_WC
21		21
22	.exit:	22	.exit:
23	ret	23	ret
24	endp	24	endp
25		25
26	; Helper procedure for mtrr_reconfigure and set_mtrr,	26	; Helper procedure for mtrr_reconfigure and set_mtrr,
27	; called before changes in MTRRs.	27	; called before changes in MTRRs.
28	; 1. disable and flush caches	28	; 1. disable and flush caches
29	; 2. clear PGE bit in cr4	29	; 2. clear PGE bit in cr4
30	; 3. flush TLB	30	; 3. flush TLB
31	; 4. disable mtrr	31	; 4. disable mtrr
32		32
33	proc mtrr_begin_change	33	proc mtrr_begin_change
34	mov eax, cr0	34	mov eax, cr0
35	or eax, 0x60000000 ;disable caching	35	or eax, 0x60000000 ;disable caching
36	mov cr0, eax	36	mov cr0, eax
37	wbinvd ;invalidate cache	37	wbinvd ;invalidate cache
38		38
39	bt [cpu_caps], CAPS_PGE	39	bt [cpu_caps], CAPS_PGE
40	jnc .cr3_flush	40	jnc .cr3_flush
41		41
42	mov eax, cr4	42	mov eax, cr4
43	btr eax, 7 ;clear cr4.PGE	43	btr eax, 7 ;clear cr4.PGE
44	mov cr4, eax ;flush TLB	44	mov cr4, eax ;flush TLB
45	jmp @F ;skip extra serialization	45	jmp @F ;skip extra serialization
46		46
47	.cr3_flush:	47	.cr3_flush:
48	mov eax, cr3	48	mov eax, cr3
49	mov cr3, eax ;flush TLB	49	mov cr3, eax ;flush TLB
50	@@:	50	@@:
51	mov ecx, MSR_MTRR_DEF_TYPE	51	mov ecx, MSR_MTRR_DEF_TYPE
52	rdmsr	52	rdmsr
53	btr eax, 11 ;clear enable flag	53	btr eax, 11 ;clear enable flag
54	wrmsr ;disable mtrr	54	wrmsr ;disable mtrr
55	ret	55	ret
56	endp	56	endp
57		57
58	; Helper procedure for mtrr_reconfigure and set_mtrr,	58	; Helper procedure for mtrr_reconfigure and set_mtrr,
59	; called after changes in MTRRs.	59	; called after changes in MTRRs.
60	; 1. enable mtrr	60	; 1. enable mtrr
61	; 2. flush all caches	61	; 2. flush all caches
62	; 3. flush TLB	62	; 3. flush TLB
63	; 4. restore cr4.PGE flag, if required	63	; 4. restore cr4.PGE flag, if required
64		64
65	proc mtrr_end_change	65	proc mtrr_end_change
66	mov ecx, MSR_MTRR_DEF_TYPE	66	mov ecx, MSR_MTRR_DEF_TYPE
67	rdmsr	67	rdmsr
68	or ah, 8 ; enable variable-ranges MTRR	68	or ah, 8 ; enable variable-ranges MTRR
69	and al, 0xF0 ; default memtype = UC	69	and al, 0xF0 ; default memtype = UC
70	wrmsr	70	wrmsr
71		71
72	wbinvd ;again invalidate	72	wbinvd ;again invalidate
73	mov eax, cr0	73	mov eax, cr0
74	and eax, not 0x60000000	74	and eax, not 0x60000000
75	mov cr0, eax ; enable caching	75	mov cr0, eax ; enable caching
76		76
77	mov eax, cr3	77	mov eax, cr3
78	mov cr3, eax ;flush tlb	78	mov cr3, eax ;flush tlb
79		79
80	bt [cpu_caps], CAPS_PGE	80	bt [cpu_caps], CAPS_PGE
81	jnc @F	81	jnc @F
82		82
83	mov eax, cr4	83	mov eax, cr4
84	bts eax, 7 ;set cr4.PGE flag	84	bts eax, 7 ;set cr4.PGE flag
85	mov cr4, eax	85	mov cr4, eax
86	@@:	86	@@:
87	ret	87	ret
88	endp	88	endp
89		89
90	; Some limits to number of structures located in the stack.	90	; Some limits to number of structures located in the stack.
91	MAX_USEFUL_MTRRS = 16	91	MAX_USEFUL_MTRRS = 16
92	MAX_RANGES = 16	92	MAX_RANGES = 16
93		93
94	; mtrr_reconfigure keeps a list of MEM_WB ranges.	94	; mtrr_reconfigure keeps a list of MEM_WB ranges.
95	; This structure describes one item in the list.	95	; This structure describes one item in the list.
96	struct mtrr_range	96	struct mtrr_range
97	next dd ? ; next item	97	next dd ? ; next item
98	start dq ? ; first byte	98	start dq ? ; first byte
99	length dq ? ; length in bytes	99	length dq ? ; length in bytes
100	ends	100	ends
101		101
102	uglobal	102	uglobal
103	align 4	103	align 4
104	num_variable_mtrrs dd 0 ; number of variable-range MTRRs	104	num_variable_mtrrs dd 0 ; number of variable-range MTRRs
105	endg	105	endg
106		106
107	; Helper procedure for MTRR initialization.	107	; Helper procedure for MTRR initialization.
108	; Takes MTRR configured by BIOS and tries to recongifure them	108	; Takes MTRR configured by BIOS and tries to recongifure them
109	; in order to allow non-UC data at top of 4G memory.	109	; in order to allow non-UC data at top of 4G memory.
110	; Example: if low part of physical memory is 3.5G = 0xE0000000 bytes wide,	110	; Example: if low part of physical memory is 3.5G = 0xE0000000 bytes wide,
111	; BIOS can configure two MTRRs so that the first MTRR describes [0, 4G) as WB	111	; BIOS can configure two MTRRs so that the first MTRR describes [0, 4G) as WB
112	; and the second MTRR describes [3.5G, 4G) as UC;	112	; and the second MTRR describes [3.5G, 4G) as UC;
113	; WB+UC=UC, so the resulting memory map would be as needed,	113	; WB+UC=UC, so the resulting memory map would be as needed,
114	; but in this configuration our attempts to map LFB at (say) 0xE8000000 as WC	114	; but in this configuration our attempts to map LFB at (say) 0xE8000000 as WC
115	; would be ignored, WB+UC+WC is still UC.	115	; would be ignored, WB+UC+WC is still UC.
116	; So we must keep top of 4G memory not covered by MTRRs,	116	; So we must keep top of 4G memory not covered by MTRRs,
117	; using three WB MTRRs [0,2G) + [2G,3G) + [3G,3.5G),	117	; using three WB MTRRs [0,2G) + [2G,3G) + [3G,3.5G),
118	; this gives the same memory map, but allows to add further entries.	118	; this gives the same memory map, but allows to add further entries.
119	; See mtrrtest.asm for detailed input/output from real hardware+BIOS.	119	; See mtrrtest.asm for detailed input/output from real hardware+BIOS.
120	proc mtrr_reconfigure	120	proc mtrr_reconfigure
121	push ebp ; we're called from init_LFB, and it feels hurt when ebp is destroyed	121	push ebp ; we're called from init_LFB, and it feels hurt when ebp is destroyed
122	; 1. Prepare local variables.	122	; 1. Prepare local variables.
123	; 1a. Create list of MAX_RANGES free (aka not yet allocated) ranges.	123	; 1a. Create list of MAX_RANGES free (aka not yet allocated) ranges.
124	xor eax, eax	124	xor eax, eax
125	lea ecx, [eax+MAX_RANGES]	125	lea ecx, [eax + MAX_RANGES]
126	.init_ranges:	126	.init_ranges:
127	sub esp, sizeof.mtrr_range - 4	127	sub esp, sizeof.mtrr_range - 4
128	push eax	128	push eax
129	mov eax, esp	129	mov eax, esp
130	dec ecx	130	dec ecx
131	jnz .init_ranges	131	jnz .init_ranges
132	mov eax, esp	132	mov eax, esp
133	; 1b. Fill individual local variables.	133	; 1b. Fill individual local variables.
134	xor edx, edx	134	xor edx, edx
135	sub esp, MAX_USEFUL_MTRRS * 16 ; .mtrrs	135	sub esp, MAX_USEFUL_MTRRS * 16 ; .mtrrs
136	push edx ; .mtrrs_end	136	push edx ; .mtrrs_end
137	push edx ; .num_used_mtrrs	137	push edx ; .num_used_mtrrs
138	push eax ; .first_free_range	138	push eax ; .first_free_range
139	push edx ; .first_range: no ranges yet	139	push edx ; .first_range: no ranges yet
140	mov cl, [cpu_phys_addr_width]	140	mov cl, [cpu_phys_addr_width]
141	or eax, -1	141	or eax, -1
142	shl eax, cl ; note: this uses cl&31 = cl-32, not the entire cl	142	shl eax, cl ; note: this uses cl&31 = cl-32, not the entire cl
143	push eax ; .phys_reserved_mask	143	push eax ; .phys_reserved_mask
144	virtual at esp	144	virtual at esp
145	.phys_reserved_mask dd ?	145	.phys_reserved_mask dd ?
146	.first_range dd ?	146	.first_range dd ?
147	.first_free_range dd ?	147	.first_free_range dd ?
148	.num_used_mtrrs dd ?	148	.num_used_mtrrs dd ?
149	.mtrrs_end dd ?	149	.mtrrs_end dd ?
150	.mtrrs rq MAX_USEFUL_MTRRS * 2	150	.mtrrs rq MAX_USEFUL_MTRRS * 2
151	.local_vars_size = $ - esp	151	.local_vars_size = $ - esp
152	end virtual	152	end virtual
153		153
154	; 2. Get the number of variable-range MTRRs from MTRRCAP register.	154	; 2. Get the number of variable-range MTRRs from MTRRCAP register.
155	; Abort if zero.	155	; Abort if zero.
156	mov ecx, 0xFE	156	mov ecx, 0xFE
157	rdmsr	157	rdmsr
158	test al, al	158	test al, al
159	jz .abort	159	jz .abort
160	mov byte [num_variable_mtrrs], al	160	mov byte [num_variable_mtrrs], al
161	; 3. Validate MTRR_DEF_TYPE register.	161	; 3. Validate MTRR_DEF_TYPE register.
162	mov ecx, 0x2FF	162	mov ecx, 0x2FF
163	rdmsr	163	rdmsr
164	; If BIOS has not initialized variable-range MTRRs, fallback to step 7.	164	; If BIOS has not initialized variable-range MTRRs, fallback to step 7.
165	test ah, 8	165	test ah, 8
166	jz .fill_ranges_from_memory_map	166	jz .fill_ranges_from_memory_map
167	; If the default memory type (not covered by MTRRs) is not UC,	167	; If the default memory type (not covered by MTRRs) is not UC,
168	; then probably BIOS did something strange, so it is better to exit immediately	168	; then probably BIOS did something strange, so it is better to exit immediately
169	; hoping for the best.	169	; hoping for the best.
170	cmp al, MEM_UC	170	cmp al, MEM_UC
171	jnz .abort	171	jnz .abort
172	; 4. Validate all variable-range MTRRs	172	; 4. Validate all variable-range MTRRs
173	; and copy configured MTRRs to the local array [.mtrrs].	173	; and copy configured MTRRs to the local array [.mtrrs].
174	; 4a. Prepare for the loop over existing variable-range MTRRs.	174	; 4a. Prepare for the loop over existing variable-range MTRRs.
175	mov ecx, 0x200	175	mov ecx, 0x200
176	lea edi, [.mtrrs]	176	lea edi, [.mtrrs]
177	.get_used_mtrrs_loop:	177	.get_used_mtrrs_loop:
178	; 4b. For every MTRR, read PHYSBASEn and PHYSMASKn.	178	; 4b. For every MTRR, read PHYSBASEn and PHYSMASKn.
179	; In PHYSBASEn, clear upper bits and copy to ebp:ebx.	179	; In PHYSBASEn, clear upper bits and copy to ebp:ebx.
180	rdmsr	180	rdmsr
181	or edx, [.phys_reserved_mask]	181	or edx, [.phys_reserved_mask]
182	xor edx, [.phys_reserved_mask]	182	xor edx, [.phys_reserved_mask]
183	mov ebp, edx	183	mov ebp, edx
184	mov ebx, eax	184	mov ebx, eax
185	inc ecx	185	inc ecx
186	; If PHYSMASKn is not active, ignore this MTRR.	186	; If PHYSMASKn is not active, ignore this MTRR.
187	rdmsr	187	rdmsr
188	inc ecx	188	inc ecx
189	test ah, 8	189	test ah, 8
190	jz .get_used_mtrrs_next	190	jz .get_used_mtrrs_next
191	; 4c. For every active MTRR, check that number of local entries is not too large.	191	; 4c. For every active MTRR, check that number of local entries is not too large.
192	inc [.num_used_mtrrs]	192	inc [.num_used_mtrrs]
193	cmp [.num_used_mtrrs], MAX_USEFUL_MTRRS	193	cmp [.num_used_mtrrs], MAX_USEFUL_MTRRS
194	ja .abort	194	ja .abort
195	; 4d. For every active MTRR, store PHYSBASEn with upper bits cleared.	195	; 4d. For every active MTRR, store PHYSBASEn with upper bits cleared.
196	; This contains the MTRR base and the memory type in low byte.	196	; This contains the MTRR base and the memory type in low byte.
197	mov [edi], ebx	197	mov [edi], ebx
198	mov [edi+4], ebp	198	mov [edi+4], ebp
199	; 4e. For every active MTRR, check that the range is continuous:	199	; 4e. For every active MTRR, check that the range is continuous:
200	; PHYSMASKn with upper bits set must be negated power of two, and	200	; PHYSMASKn with upper bits set must be negated power of two, and
201	; low bits of PHYSBASEn must be zeroes:	201	; low bits of PHYSBASEn must be zeroes:
202	; PHYSMASKn = 1...10...0,	202	; PHYSMASKn = 1...10...0,
203	; PHYSBASEn = x...x0...0,	203	; PHYSBASEn = x...x0...0,
204	; this defines a continuous range from x...x0...0 to x...x1...1,	204	; this defines a continuous range from x...x0...0 to x...x1...1,
205	; length = 10...0 = negated PHYSMASKn.	205	; length = 10...0 = negated PHYSMASKn.
206	; Store length in the local array.	206	; Store length in the local array.
207	and eax, not 0xFFF	207	and eax, not 0xFFF
208	or edx, [.phys_reserved_mask]	208	or edx, [.phys_reserved_mask]
209	mov dword [edi+8], 0	209	mov dword [edi+8], 0
210	mov dword [edi+12], 0	210	mov dword [edi+12], 0
211	sub [edi+8], eax	211	sub [edi+8], eax
212	sbb [edi+12], edx	212	sbb [edi+12], edx
213	; (x and -x) is the maximum power of two that divides x.	213	; (x and -x) is the maximum power of two that divides x.
214	; Condition for powers of two: (x and -x) equals x.	214	; Condition for powers of two: (x and -x) equals x.
215	and eax, [edi+8]	215	and eax, [edi+8]
216	and edx, [edi+12]	216	and edx, [edi+12]
217	cmp eax, [edi+8]	217	cmp eax, [edi+8]
218	jnz .abort	218	jnz .abort
219	cmp edx, [edi+12]	219	cmp edx, [edi+12]
220	jnz .abort	220	jnz .abort
221	sub eax, 1	221	sub eax, 1
222	sbb edx, 0	222	sbb edx, 0
223	and eax, not 0xFFF	223	and eax, not 0xFFF
224	and eax, ebx	224	and eax, ebx
225	jnz .abort	225	jnz .abort
226	and edx, ebp	226	and edx, ebp
227	jnz .abort	227	jnz .abort
228	; 4f. For every active MTRR, validate memory type: it must be either WB or UC.	228	; 4f. For every active MTRR, validate memory type: it must be either WB or UC.
229	add edi, 16	229	add edi, 16
230	cmp bl, MEM_UC	230	cmp bl, MEM_UC
231	jz .get_used_mtrrs_next	231	jz .get_used_mtrrs_next
232	cmp bl, MEM_WB	232	cmp bl, MEM_WB
233	jnz .abort	233	jnz .abort
234	.get_used_mtrrs_next:	234	.get_used_mtrrs_next:
235	; 4g. Repeat the loop at 4b-4f for all [num_variable_mtrrs] entries.	235	; 4g. Repeat the loop at 4b-4f for all [num_variable_mtrrs] entries.
236	mov eax, [num_variable_mtrrs]	236	mov eax, [num_variable_mtrrs]
237	lea eax, [0x200+eax*2]	237	lea eax, [0x200+eax*2]
238	cmp ecx, eax	238	cmp ecx, eax
239	jb .get_used_mtrrs_loop	239	jb .get_used_mtrrs_loop
240	; 4h. If no active MTRRs were detected, fallback to step 7.	240	; 4h. If no active MTRRs were detected, fallback to step 7.
241	cmp [.num_used_mtrrs], 0	241	cmp [.num_used_mtrrs], 0
242	jz .fill_ranges_from_memory_map	242	jz .fill_ranges_from_memory_map
243	mov [.mtrrs_end], edi	243	mov [.mtrrs_end], edi
244	; 5. Generate sorted list of ranges marked as WB.	244	; 5. Generate sorted list of ranges marked as WB.
245	; 5a. Prepare for the loop over configured MTRRs filled at step 4.	245	; 5a. Prepare for the loop over configured MTRRs filled at step 4.
246	lea ecx, [.mtrrs]	246	lea ecx, [.mtrrs]
247	.fill_wb_ranges:	247	.fill_wb_ranges:
248	; 5b. Ignore non-WB MTRRs.	248	; 5b. Ignore non-WB MTRRs.
249	mov ebx, [ecx]	249	mov ebx, [ecx]
250	cmp bl, MEM_WB	250	cmp bl, MEM_WB
251	jnz .next_wb_range	251	jnz .next_wb_range
252	mov ebp, [ecx+4]	252	mov ebp, [ecx+4]
253	and ebx, not 0xFFF ; clear memory type and reserved bits	253	and ebx, not 0xFFF ; clear memory type and reserved bits
254	; ebp:ebx = start of the range described by the current MTRR.	254	; ebp:ebx = start of the range described by the current MTRR.
255	; 5c. Find the first existing range containing a point greater than ebp:ebx.	255	; 5c. Find the first existing range containing a point greater than ebp:ebx.
256	lea esi, [.first_range]	256	lea esi, [.first_range]
257	.find_range_wb:	257	.find_range_wb:
258	; If there is no next range or start of the next range is greater than ebp:ebx,	258	; If there is no next range or start of the next range is greater than ebp:ebx,
259	; exit the loop to 5d.	259	; exit the loop to 5d.
260	mov edi, [esi]	260	mov edi, [esi]
261	test edi, edi	261	test edi, edi
262	jz .found_place_wb	262	jz .found_place_wb
263	mov eax, ebx	263	mov eax, ebx
264	mov edx, ebp	264	mov edx, ebp
265	sub eax, dword [edi+mtrr_range.start]	265	sub eax, dword [edi + mtrr_range.start]
266	sbb edx, dword [edi+mtrr_range.start+4]	266	sbb edx, dword [edi + mtrr_range.start+4]
267	jb .found_place_wb	267	jb .found_place_wb
268	; Otherwise, if end of the next range is greater than or equal to ebp:ebx,	268	; Otherwise, if end of the next range is greater than or equal to ebp:ebx,
269	; exit the loop to 5e.	269	; exit the loop to 5e.
270	mov esi, edi	270	mov esi, edi
271	sub eax, dword [edi+mtrr_range.length]	271	sub eax, dword [edi + mtrr_range.length]
272	sbb edx, dword [edi+mtrr_range.length+4]	272	sbb edx, dword [edi + mtrr_range.length+4]
273	jb .expand_wb	273	jb .expand_wb
274	or eax, edx	274	or eax, edx
275	jnz .find_range_wb	275	jnz .find_range_wb
276	jmp .expand_wb	276	jmp .expand_wb
277	.found_place_wb:	277	.found_place_wb:
278	; 5d. ebp:ebx is not within any existing range.	278	; 5d. ebp:ebx is not within any existing range.
279	; Insert a new range between esi and edi.	279	; Insert a new range between esi and edi.
280	; (Later, during 5e, it can be merged with the following ranges.)	280	; (Later, during 5e, it can be merged with the following ranges.)
281	mov eax, [.first_free_range]	281	mov eax, [.first_free_range]
282	test eax, eax	282	test eax, eax
283	jz .abort	283	jz .abort
284	mov [esi], eax	284	mov [esi], eax
285	mov edx, [eax+mtrr_range.next]	285	mov edx, [eax + mtrr_range.next]
286	mov [.first_free_range], edx	286	mov [.first_free_range], edx
287	mov dword [eax+mtrr_range.start], ebx	287	mov dword [eax + mtrr_range.start], ebx
288	mov dword [eax+mtrr_range.start+4], ebp	288	mov dword [eax + mtrr_range.start+4], ebp
289	; Don't fill [eax+mtrr_range.next] and [eax+mtrr_range.length] yet,	289	; Don't fill [eax+mtrr_range.next] and [eax+mtrr_range.length] yet,
290	; they will be calculated including merges at step 5e.	290	; they will be calculated including merges at step 5e.
291	mov esi, edi	291	mov esi, edi
292	mov edi, eax	292	mov edi, eax
293	.expand_wb:	293	.expand_wb:
294	; 5e. The range at edi contains ebp:ebx, and esi points to the first range	294	; 5e. The range at edi contains ebp:ebx, and esi points to the first range
295	; to be checked for merge: esi=edi if ebp:ebx was found in an existing range,	295	; to be checked for merge: esi=edi if ebp:ebx was found in an existing range,
296	; esi is next after edi if a new range with ebp:ebx was created.	296	; esi is next after edi if a new range with ebp:ebx was created.
297	; Merge it with following ranges while start of the next range is not greater	297	; Merge it with following ranges while start of the next range is not greater
298	; than the end of the new range.	298	; than the end of the new range.
299	add ebx, [ecx+8]	299	add ebx, [ecx+8]
300	adc ebp, [ecx+12]	300	adc ebp, [ecx+12]
301	; ebp:ebx = end of the range described by the current MTRR.	301	; ebp:ebx = end of the range described by the current MTRR.
302	.expand_wb_loop:	302	.expand_wb_loop:
303	; If there is no next range or start of the next range is greater than ebp:ebx,	303	; If there is no next range or start of the next range is greater than ebp:ebx,
304	; exit the loop to 5g.	304	; exit the loop to 5g.
305	test esi, esi	305	test esi, esi
306	jz .expand_wb_done	306	jz .expand_wb_done
307	mov eax, ebx	307	mov eax, ebx
308	mov edx, ebp	308	mov edx, ebp
309	sub eax, dword [esi+mtrr_range.start]	309	sub eax, dword [esi + mtrr_range.start]
310	sbb edx, dword [esi+mtrr_range.start+4]	310	sbb edx, dword [esi + mtrr_range.start+4]
311	jb .expand_wb_done	311	jb .expand_wb_done
312	; Otherwise, if end of the next range is greater than or equal to ebp:ebx,	312	; Otherwise, if end of the next range is greater than or equal to ebp:ebx,
313	; exit the loop to 5f.	313	; exit the loop to 5f.
314	sub eax, dword [esi+mtrr_range.length]	314	sub eax, dword [esi + mtrr_range.length]
315	sbb edx, dword [esi+mtrr_range.length+4]	315	sbb edx, dword [esi + mtrr_range.length+4]
316	jb .expand_wb_last	316	jb .expand_wb_last
317	; Otherwise, the current range is completely within the new range.	317	; Otherwise, the current range is completely within the new range.
318	; Free it and continue the loop.	318	; Free it and continue the loop.
319	mov edx, [esi+mtrr_range.next]	319	mov edx, [esi + mtrr_range.next]
320	cmp esi, edi	320	cmp esi, edi
321	jz @f	321	jz @f
322	mov eax, [.first_free_range]	322	mov eax, [.first_free_range]
323	mov [esi+mtrr_range.next], eax	323	mov [esi + mtrr_range.next], eax
324	mov [.first_free_range], esi	324	mov [.first_free_range], esi
325	@@:	325	@@:
326	mov esi, edx	326	mov esi, edx
327	jmp .expand_wb_loop	327	jmp .expand_wb_loop
328	.expand_wb_last:	328	.expand_wb_last:
329	; 5f. Start of the new range is inside range described by esi,	329	; 5f. Start of the new range is inside range described by esi,
330	; end of the new range is inside range described by edi.	330	; end of the new range is inside range described by edi.
331	; If esi is equal to edi, the new range is completely within	331	; If esi is equal to edi, the new range is completely within
332	; an existing range, so proceed to the next range.	332	; an existing range, so proceed to the next range.
333	cmp esi, edi	333	cmp esi, edi
334	jz .next_wb_range	334	jz .next_wb_range
335	; Otherwise, set end of interval at esi to end of interval at edi	335	; Otherwise, set end of interval at esi to end of interval at edi
336	; and free range described by edi.	336	; and free range described by edi.
337	mov ebx, dword [esi+mtrr_range.start]	337	mov ebx, dword [esi + mtrr_range.start]
338	mov ebp, dword [esi+mtrr_range.start+4]	338	mov ebp, dword [esi + mtrr_range.start+4]
339	add ebx, dword [esi+mtrr_range.length]	339	add ebx, dword [esi + mtrr_range.length]
340	adc ebp, dword [esi+mtrr_range.length+4]	340	adc ebp, dword [esi + mtrr_range.length+4]
341	mov edx, [esi+mtrr_range.next]	341	mov edx, [esi + mtrr_range.next]
342	mov eax, [.first_free_range]	342	mov eax, [.first_free_range]
343	mov [esi+mtrr_range.next], eax	343	mov [esi + mtrr_range.next], eax
344	mov [.first_free_range], esi	344	mov [.first_free_range], esi
345	mov esi, edx	345	mov esi, edx
346	.expand_wb_done:	346	.expand_wb_done:
347	; 5g. We have found the next range (maybe 0) after merging and	347	; 5g. We have found the next range (maybe 0) after merging and
348	; the new end of range (maybe ebp:ebx from the new range	348	; the new end of range (maybe ebp:ebx from the new range
349	; or end of another existing interval calculated at step 5f).	349	; or end of another existing interval calculated at step 5f).
350	; Write them to range at edi.	350	; Write them to range at edi.
351	mov [edi+mtrr_range.next], esi	351	mov [edi + mtrr_range.next], esi
352	sub ebx, dword [edi+mtrr_range.start]	352	sub ebx, dword [edi + mtrr_range.start]
353	sbb ebp, dword [edi+mtrr_range.start+4]	353	sbb ebp, dword [edi + mtrr_range.start+4]
354	mov dword [edi+mtrr_range.length], ebx	354	mov dword [edi + mtrr_range.length], ebx
355	mov dword [edi+mtrr_range.length+4], ebp	355	mov dword [edi + mtrr_range.length+4], ebp
356	.next_wb_range:	356	.next_wb_range:
357	; 5h. Continue the loop 5b-5g over all configured MTRRs.	357	; 5h. Continue the loop 5b-5g over all configured MTRRs.
358	add ecx, 16	358	add ecx, 16
359	cmp ecx, [.mtrrs_end]	359	cmp ecx, [.mtrrs_end]
360	jb .fill_wb_ranges	360	jb .fill_wb_ranges
361	; 6. Exclude all ranges marked as UC.	361	; 6. Exclude all ranges marked as UC.
362	; 6a. Prepare for the loop over configured MTRRs filled at step 4.	362	; 6a. Prepare for the loop over configured MTRRs filled at step 4.
363	lea ecx, [.mtrrs]	363	lea ecx, [.mtrrs]
364	.fill_uc_ranges:	364	.fill_uc_ranges:
365	; 6b. Ignore non-UC MTRRs.	365	; 6b. Ignore non-UC MTRRs.
366	mov ebx, [ecx]	366	mov ebx, [ecx]
367	cmp bl, MEM_UC	367	cmp bl, MEM_UC
368	jnz .next_uc_range	368	jnz .next_uc_range
369	mov ebp, [ecx+4]	369	mov ebp, [ecx+4]
370	and ebx, not 0xFFF ; clear memory type and reserved bits	370	and ebx, not 0xFFF ; clear memory type and reserved bits
371	; ebp:ebx = start of the range described by the current MTRR.	371	; ebp:ebx = start of the range described by the current MTRR.
372	lea esi, [.first_range]	372	lea esi, [.first_range]
373	; 6c. Find the first existing range containing a point greater than ebp:ebx.	373	; 6c. Find the first existing range containing a point greater than ebp:ebx.
374	.find_range_uc:	374	.find_range_uc:
375	; If there is no next range, ignore this MTRR,	375	; If there is no next range, ignore this MTRR,
376	; exit the loop and continue to next MTRR.	376	; exit the loop and continue to next MTRR.
377	mov edi, [esi]	377	mov edi, [esi]
378	test edi, edi	378	test edi, edi
379	jz .next_uc_range	379	jz .next_uc_range
380	; If start of the next range is greater than or equal to ebp:ebx,	380	; If start of the next range is greater than or equal to ebp:ebx,
381	; exit the loop to 6e.	381	; exit the loop to 6e.
382	mov eax, dword [edi+mtrr_range.start]	382	mov eax, dword [edi + mtrr_range.start]
383	mov edx, dword [edi+mtrr_range.start+4]	383	mov edx, dword [edi + mtrr_range.start+4]
384	sub eax, ebx	384	sub eax, ebx
385	sbb edx, ebp	385	sbb edx, ebp
386	jnb .truncate_uc	386	jnb .truncate_uc
387	; Otherwise, continue the loop if end of the next range is less than ebp:ebx,	387	; Otherwise, continue the loop if end of the next range is less than ebp:ebx,
388	; exit the loop to 6d otherwise.	388	; exit the loop to 6d otherwise.
389	mov esi, edi	389	mov esi, edi
390	add eax, dword [edi+mtrr_range.length]	390	add eax, dword [edi + mtrr_range.length]
391	adc edx, dword [edi+mtrr_range.length+4]	391	adc edx, dword [edi + mtrr_range.length+4]
392	jnb .find_range_uc	392	jnb .find_range_uc
393	; 6d. ebp:ebx is inside (or at end of) an existing range.	393	; 6d. ebp:ebx is inside (or at end of) an existing range.
394	; Split the range. (The second range, maybe containing completely within UC-range,	394	; Split the range. (The second range, maybe containing completely within UC-range,
395	; maybe of zero length, can be removed at step 6e, if needed.)	395	; maybe of zero length, can be removed at step 6e, if needed.)
396	mov edi, [.first_free_range]	396	mov edi, [.first_free_range]
397	test edi, edi	397	test edi, edi
398	jz .abort	398	jz .abort
399	mov dword [edi+mtrr_range.start], ebx	399	mov dword [edi + mtrr_range.start], ebx
400	mov dword [edi+mtrr_range.start+4], ebp	400	mov dword [edi + mtrr_range.start+4], ebp
401	mov dword [edi+mtrr_range.length], eax	401	mov dword [edi + mtrr_range.length], eax
402	mov dword [edi+mtrr_range.length+4], edx	402	mov dword [edi + mtrr_range.length+4], edx
403	mov eax, [edi+mtrr_range.next]	403	mov eax, [edi + mtrr_range.next]
404	mov [.first_free_range], eax	404	mov [.first_free_range], eax
405	mov eax, [esi+mtrr_range.next]	405	mov eax, [esi + mtrr_range.next]
406	mov [edi+mtrr_range.next], eax	406	mov [edi + mtrr_range.next], eax
407	; don't change [esi+mtrr_range.next] yet, it will be filled at step 6e	407	; don't change [esi+mtrr_range.next] yet, it will be filled at step 6e
408	mov eax, ebx	408	mov eax, ebx
409	mov edx, ebp	409	mov edx, ebp
410	sub eax, dword [esi+mtrr_range.start]	410	sub eax, dword [esi + mtrr_range.start]
411	sbb edx, dword [esi+mtrr_range.start+4]	411	sbb edx, dword [esi + mtrr_range.start+4]
412	mov dword [esi+mtrr_range.length], eax	412	mov dword [esi + mtrr_range.length], eax
413	mov dword [esi+mtrr_range.length+4], edx	413	mov dword [esi + mtrr_range.length+4], edx
414	.truncate_uc:	414	.truncate_uc:
415	; 6e. edi is the first range after ebp:ebx, check it and next ranges	415	; 6e. edi is the first range after ebp:ebx, check it and next ranges
416	; for intersection with the new range, truncate heads.	416	; for intersection with the new range, truncate heads.
417	add ebx, [ecx+8]	417	add ebx, [ecx+8]
418	adc ebp, [ecx+12]	418	adc ebp, [ecx+12]
419	; ebp:ebx = end of the range described by the current MTRR.	419	; ebp:ebx = end of the range described by the current MTRR.
420	.truncate_uc_loop:	420	.truncate_uc_loop:
421	; If start of the next range is greater than ebp:ebx,	421	; If start of the next range is greater than ebp:ebx,
422	; exit the loop to 6g.	422	; exit the loop to 6g.
423	mov eax, ebx	423	mov eax, ebx
424	mov edx, ebp	424	mov edx, ebp
425	sub eax, dword [edi+mtrr_range.start]	425	sub eax, dword [edi + mtrr_range.start]
426	sbb edx, dword [edi+mtrr_range.start+4]	426	sbb edx, dword [edi + mtrr_range.start+4]
427	jb .truncate_uc_done	427	jb .truncate_uc_done
428	; Otherwise, if end of the next range is greater than ebp:ebx,	428	; Otherwise, if end of the next range is greater than ebp:ebx,
429	; exit the loop to 6f.	429	; exit the loop to 6f.
430	sub eax, dword [edi+mtrr_range.length]	430	sub eax, dword [edi + mtrr_range.length]
431	sbb edx, dword [edi+mtrr_range.length+4]	431	sbb edx, dword [edi + mtrr_range.length+4]
432	jb .truncate_uc_last	432	jb .truncate_uc_last
433	; Otherwise, the current range is completely within the new range.	433	; Otherwise, the current range is completely within the new range.
434	; Free it and continue the loop if there is a next range.	434	; Free it and continue the loop if there is a next range.
435	; If that was a last range, exit the loop to 6g.	435	; If that was a last range, exit the loop to 6g.
436	mov edx, [edi+mtrr_range.next]	436	mov edx, [edi + mtrr_range.next]
437	mov eax, [.first_free_range]	437	mov eax, [.first_free_range]
438	mov [.first_free_range], edi	438	mov [.first_free_range], edi
439	mov [edi+mtrr_range.next], eax	439	mov [edi + mtrr_range.next], eax
440	mov edi, edx	440	mov edi, edx
441	test edi, edi	441	test edi, edi
442	jnz .truncate_uc_loop	442	jnz .truncate_uc_loop
443	jmp .truncate_uc_done	443	jmp .truncate_uc_done
444	.truncate_uc_last:	444	.truncate_uc_last:
445	; 6f. The range at edi partially intersects with the UC-range described by MTRR.	445	; 6f. The range at edi partially intersects with the UC-range described by MTRR.
446	; Truncate it from the head.	446	; Truncate it from the head.
447	mov dword [edi+mtrr_range.start], ebx	447	mov dword [edi + mtrr_range.start], ebx
448	mov dword [edi+mtrr_range.start+4], ebp	448	mov dword [edi + mtrr_range.start+4], ebp
449	neg eax	449	neg eax
450	adc edx, 0	450	adc edx, 0
451	neg edx	451	neg edx
452	mov dword [edi+mtrr_range.length], eax	452	mov dword [edi + mtrr_range.length], eax
453	mov dword [edi+mtrr_range.length+4], edx	453	mov dword [edi + mtrr_range.length+4], edx
454	.truncate_uc_done:	454	.truncate_uc_done:
455	; 6g. We have found the next range (maybe 0) after intersection.	455	; 6g. We have found the next range (maybe 0) after intersection.
456	; Write it to [esi+mtrr_range.next].	456	; Write it to [esi+mtrr_range.next].
457	mov [esi+mtrr_range.next], edi	457	mov [esi + mtrr_range.next], edi
458	.next_uc_range:	458	.next_uc_range:
459	; 6h. Continue the loop 6b-6g over all configured MTRRs.	459	; 6h. Continue the loop 6b-6g over all configured MTRRs.
460	add ecx, 16	460	add ecx, 16
461	cmp ecx, [.mtrrs_end]	461	cmp ecx, [.mtrrs_end]
462	jb .fill_uc_ranges	462	jb .fill_uc_ranges
463	; Sanity check: if there are no ranges after steps 5-6,	463	; Sanity check: if there are no ranges after steps 5-6,
464	; fallback to step 7. Otherwise, go to 8.	464	; fallback to step 7. Otherwise, go to 8.
465	cmp [.first_range], 0	465	cmp [.first_range], 0
466	jnz .ranges_ok	466	jnz .ranges_ok
467	.fill_ranges_from_memory_map:	467	.fill_ranges_from_memory_map:
468	; 7. BIOS has not configured variable-range MTRRs.	468	; 7. BIOS has not configured variable-range MTRRs.
469	; Create one range from 0 to [MEM_AMOUNT].	469	; Create one range from 0 to [MEM_AMOUNT].
470	mov eax, [.first_free_range]	470	mov eax, [.first_free_range]
471	mov edx, [eax+mtrr_range.next]	471	mov edx, [eax + mtrr_range.next]
472	mov [.first_free_range], edx	472	mov [.first_free_range], edx
473	mov [.first_range], eax	473	mov [.first_range], eax
474	xor edx, edx	474	xor edx, edx
475	mov [eax+mtrr_range.next], edx	475	mov [eax + mtrr_range.next], edx
476	mov dword [eax+mtrr_range.start], edx	476	mov dword [eax + mtrr_range.start], edx
477	mov dword [eax+mtrr_range.start+4], edx	477	mov dword [eax + mtrr_range.start+4], edx
478	mov ecx, [MEM_AMOUNT]	478	mov ecx, [MEM_AMOUNT]
479	mov dword [eax+mtrr_range.length], ecx	479	mov dword [eax + mtrr_range.length], ecx
480	mov dword [eax+mtrr_range.length+4], edx	480	mov dword [eax + mtrr_range.length+4], edx
481	.ranges_ok:	481	.ranges_ok:
482	; 8. We have calculated list of WB-ranges.	482	; 8. We have calculated list of WB-ranges.
483	; Now we should calculate a list of MTRRs so that	483	; Now we should calculate a list of MTRRs so that
484	; * every MTRR describes a range with length = power of 2 and start that is aligned,	484	; * every MTRR describes a range with length = power of 2 and start that is aligned,
485	; * every MTRR can be WB or UC	485	; * every MTRR can be WB or UC
486	; * (sum of all WB ranges) minus (sum of all UC ranges) equals the calculated list	486	; * (sum of all WB ranges) minus (sum of all UC ranges) equals the calculated list
487	; * top of 4G memory must not be covered by any ranges	487	; * top of 4G memory must not be covered by any ranges
488	; Example: range [0,0xBC000000) can be converted to	488	; Example: range [0,0xBC000000) can be converted to
489	; [0,0x80000000)+[0x80000000,0xC0000000)-[0xBC000000,0xC0000000)	489	; [0,0x80000000)+[0x80000000,0xC0000000)-[0xBC000000,0xC0000000)
490	; WB +WB -UC	490	; WB +WB -UC
491	; but not to [0,0x100000000)-[0xC0000000,0x100000000)-[0xBC000000,0xC0000000).	491	; but not to [0,0x100000000)-[0xC0000000,0x100000000)-[0xBC000000,0xC0000000).
492	; 8a. Check that list of ranges is [0,something) plus, optionally, [4G,something).	492	; 8a. Check that list of ranges is [0,something) plus, optionally, [4G,something).
493	; This holds in practice (see mtrrtest.asm for real-life examples)	493	; This holds in practice (see mtrrtest.asm for real-life examples)
494	; and significantly simplifies the code: ranges are independent, start of range	494	; and significantly simplifies the code: ranges are independent, start of range
495	; is almost always aligned (the only exception >4G upper memory can be easily covered),	495	; is almost always aligned (the only exception >4G upper memory can be easily covered),
496	; there is no need to consider adding holes before start of range, only	496	; there is no need to consider adding holes before start of range, only
497	; append them to end of range.	497	; append them to end of range.
498	xor eax, eax	498	xor eax, eax
499	mov edi, [.first_range]	499	mov edi, [.first_range]
500	cmp dword [edi+mtrr_range.start], eax	500	cmp dword [edi + mtrr_range.start], eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/mtrr.inc – Rev 7132 → 9715