;; -----------------------------------------------------------------------
;;
;; Copyright 1994-2009 H. Peter Anvin - All Rights Reserved
;; Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
;; Boston MA 02111-1307, USA; either version 2 of the License, or
;; (at your option) any later version; incorporated herein by reference.
;;
;; -----------------------------------------------------------------------
;;
;; bcopy32xx.inc
;;
;
; 32-bit bcopy routine
;
; This is the actual 32-bit portion of the bcopy and shuffle and boot
; routines. ALL THIS CODE NEEDS TO BE POSITION-INDEPENDENT, with the
; sole exception being the actual relocation code at the beginning of
; pm_shuffle_boot.
;
; It also really needs to live all in a single segment, for the
; address calculcations to actually work.
;
bits 32
section .bcopyxx.text
align 16
;
; pm_bcopy:
;
; This is the protected-mode core of the "bcopy" routine.
; Try to do aligned transfers; if the src and dst are relatively
; misaligned, align the dst.
;
; ECX is guaranteed to not be zero on entry.
;
; Clobbers ESI, EDI, ECX.
;
pm_bcopy:
push ebx
push edx
push eax
cmp esi,-1
je .bzero
cmp esi,edi ; If source < destination, we might
jb .reverse ; have to copy backwards
.forward:
; Initial alignment
mov edx,edi
shr edx,1
jnc .faa1
movsb
dec ecx
.faa1:
mov al,cl
cmp ecx,2
jb .f_tiny
shr edx,1
jnc .faa2
movsw
sub ecx,2
.faa2:
; Bulk transfer
mov al,cl ; Save low bits
shr ecx,2 ; Convert to dwords
rep movsd ; Do our business
; At this point ecx == 0
test al,2
jz .fab2
movsw
.fab2:
.f_tiny:
test al,1
jz .fab1
movsb
.fab1:
.done:
pop eax
pop edx
pop ebx
ret
.reverse:
lea eax,[esi+ecx-1] ; Point to final byte
cmp edi,eax
ja .forward ; No overlap, do forward copy
std ; Reverse copy
lea edi,[edi+ecx-1]
mov esi,eax
; Initial alignment
mov edx,edi
shr edx,1
jc .raa1
movsb
dec ecx
.raa1:
dec esi
dec edi
mov al,cl
cmp ecx,2
jb .r_tiny
shr edx,1
jc .raa2
movsw
sub ecx,2
.raa2:
; Bulk copy
sub esi,2
sub edi,2
mov al,cl ; Save low bits
shr ecx,2
rep movsd
; Final alignment
.r_final:
add esi,2
add edi,2
test al,2
jz .rab2
movsw
.rab2:
.r_tiny:
inc esi
inc edi
test al,1
jz .rab1
movsb
.rab1:
cld
jmp short .done
.bzero:
xor eax,eax
; Initial alignment
mov edx,edi
shr edx,1
jnc .zaa1
stosb
dec ecx
.zaa1:
mov bl,cl
cmp ecx,2
jb .z_tiny
shr edx,1
jnc .zaa2
stosw
sub ecx,2
.zaa2:
; Bulk
mov bl,cl ; Save low bits
shr ecx,2
rep stosd
test bl,2
jz .zab2
stosw
.zab2:
.z_tiny:
test bl,1
jz .zab1
stosb
.zab1:
jmp short .done
;
; shuffle_and_boot:
;
; This routine is used to shuffle memory around, followed by
; invoking an entry point somewhere in low memory. This routine
; can clobber any memory outside the bcopy special area.
;
; IMPORTANT: This routine does not set up any registers.
; It is the responsibility of the caller to generate an appropriate entry
; stub; *especially* when going to real mode.
;
; Inputs:
; ESI -> Pointer to list of (dst, src, len) pairs(*)
; EDI -> Pointer to safe area for list + shuffler
; (must not overlap this code nor the RM stack)
; ECX -> Byte count of list area (for initial copy)
;
; If src == -1: then the memory pointed to by (dst, len) is bzeroed;
; this is handled inside the bcopy routine.
;
; If len == 0: this marks the end of the list; dst indicates
; the entry point and src the mode (0 = pm, 1 = rm)
;
pm_shuffle:
cli ; End interrupt service (for good)
mov ebx,edi ; EBX <- descriptor list
lea edx,[edi+ecx+15] ; EDX <- where to relocate our code to
and edx,~15 ; Align 16 to benefit the GDT
call pm_bcopy
mov esi,__bcopyxx_start ; Absolute source address
mov edi,edx ; Absolute target address
sub edx,esi ; EDX <- address delta
mov ecx,__bcopyxx_dwords
lea eax,[edx+.safe] ; Resume point
; Relocate this code
rep movsd
jmp eax ; Jump to safe location
.safe:
; Give ourselves a safe stack
lea esp,[edx+bcopyxx_stack+__bcopyxx_end]
add edx,bcopy_gdt ; EDX <- new GDT
mov [edx+2],edx ; GDT self-pointer
lgdt [edx] ; Switch to local GDT
; Now for the actual shuffling...
.loop:
mov edi,[ebx]
mov esi,[ebx+4]
mov ecx,[ebx+8]
add ebx,12
jecxz .done
call pm_bcopy
jmp .loop
.done:
lidt [edx+RM_IDT_ptr-bcopy_gdt] ; RM-like IDT
push ecx ; == 0, for cleaning the flags register
and esi,esi
jz pm_shuffle_16
popfd ; Clean the flags
jmp edi ; Protected mode entry
; We have a 16-bit entry point, so we need to return
; to 16-bit mode. Note: EDX already points to the GDT.
pm_shuffle_16:
mov eax,edi
mov [edx+PM_CS16+2],ax
mov [edx+PM_DS16+2],ax
shr eax,16
mov [edx+PM_CS16+4],al
mov [edx+PM_CS16+7],ah
mov [edx+PM_DS16+4],al
mov [edx+PM_DS16+7],ah
mov eax,cr0
and al,~1
popfd ; Clean the flags
; No flag-changing instructions below...
mov dx,PM_DS16
mov ds,edx
mov es,edx
mov fs,edx
mov gs,edx
mov ss,edx
jmp PM_CS16:0
section .bcopyxx.data
alignz 16
; GDT descriptor entry
%macro desc 1
bcopy_gdt.%1:
PM_%1 equ bcopy_gdt.%1-bcopy_gdt
%endmacro
bcopy_gdt:
dw bcopy_gdt_size-1 ; Null descriptor - contains GDT
dd bcopy_gdt ; pointer for LGDT instruction
dw 0
; TSS segment to keep Intel VT happy. Intel VT is
; unhappy about anything that doesn't smell like a
; full-blown 32-bit OS.
desc TSS
dw 104-1, DummyTSS ; 08h 32-bit task state segment
dd 00008900h ; present, dpl 0, 104 bytes @DummyTSS
desc CS16
dd 0000ffffh ; 10h Code segment, use16, readable,
dd 00009b00h ; present, dpl 0, cover 64K
desc DS16
dd 0000ffffh ; 18h Data segment, use16, read/write,
dd 00009300h ; present, dpl 0, cover 64K
desc CS32
dd 0000ffffh ; 20h Code segment, use32, readable,
dd 00cf9b00h ; present, dpl 0, cover all 4G
desc DS32
dd 0000ffffh ; 28h Data segment, use32, read/write,
dd 00cf9300h ; present, dpl 0, cover all 4G
bcopy_gdt_size: equ $-bcopy_gdt
;
; Space for a dummy task state segment. It should never be actually
; accessed, but just in case it is, point to a chunk of memory that
; has a chance to not be used for anything real...
;
DummyTSS equ 0x580
align 4
RM_IDT_ptr: dw 0FFFFh ; Length (nonsense, but matches CPU)
dd 0 ; Offset
bcopyxx_stack equ 128 ; We want this much stack
bits 16
section .text16
