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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/mtrr.inc – Rev 5351 → 5356