mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-30 06:53:09 +00:00
303 lines
6.5 KiB
ArmAsm
303 lines
6.5 KiB
ArmAsm
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* From coreboot x86_asm.S, cleaned up substantially
|
|
*
|
|
* Copyright (C) 2009-2010 coresystems GmbH
|
|
*/
|
|
|
|
#include <asm/processor.h>
|
|
#include <asm/processor-flags.h>
|
|
#include "bios.h"
|
|
|
|
#define SEG(segment) $segment * X86_GDT_ENTRY_SIZE
|
|
|
|
/*
|
|
* This is the interrupt handler stub code. It gets copied to the IDT and
|
|
* to some fixed addresses in the F segment. Before the code can used,
|
|
* it gets patched up by the C function copying it: byte 3 (the $0 in
|
|
* movb $0, %al) is overwritten with the interrupt numbers.
|
|
*/
|
|
|
|
.code16
|
|
.globl __idt_handler
|
|
__idt_handler:
|
|
pushal
|
|
movb $0, %al /* This instruction gets modified */
|
|
ljmp $0, $__interrupt_handler_16bit
|
|
.globl __idt_handler_size
|
|
__idt_handler_size:
|
|
.long . - __idt_handler
|
|
|
|
.macro setup_registers
|
|
/* initial register values */
|
|
movl 44(%ebp), %eax
|
|
movl %eax, __registers + 0 /* eax */
|
|
movl 48(%ebp), %eax
|
|
movl %eax, __registers + 4 /* ebx */
|
|
movl 52(%ebp), %eax
|
|
movl %eax, __registers + 8 /* ecx */
|
|
movl 56(%ebp), %eax
|
|
movl %eax, __registers + 12 /* edx */
|
|
movl 60(%ebp), %eax
|
|
movl %eax, __registers + 16 /* esi */
|
|
movl 64(%ebp), %eax
|
|
movl %eax, __registers + 20 /* edi */
|
|
.endm
|
|
|
|
.macro enter_real_mode
|
|
/* Activate the right segment descriptor real mode. */
|
|
ljmp SEG(X86_GDT_ENTRY_16BIT_CS), $PTR_TO_REAL_MODE(1f)
|
|
1:
|
|
.code16
|
|
/*
|
|
* Load the segment registers with properly configured segment
|
|
* descriptors. They will retain these configurations (limits,
|
|
* writability, etc.) once protected mode is turned off.
|
|
*/
|
|
mov SEG(X86_GDT_ENTRY_16BIT_DS), %ax
|
|
mov %ax, %ds
|
|
mov %ax, %es
|
|
mov %ax, %fs
|
|
mov %ax, %gs
|
|
mov %ax, %ss
|
|
|
|
/* Turn off protection */
|
|
movl %cr0, %eax
|
|
andl $~X86_CR0_PE, %eax
|
|
movl %eax, %cr0
|
|
|
|
/* Now really going into real mode */
|
|
ljmp $0, $PTR_TO_REAL_MODE(1f)
|
|
1:
|
|
/*
|
|
* Set up a stack: Put the stack at the end of page zero. That way
|
|
* we can easily share it between real and protected, since the
|
|
* 16-bit ESP at segment 0 will work for any case.
|
|
*/
|
|
mov $0x0, %ax
|
|
mov %ax, %ss
|
|
|
|
/* Load 16 bit IDT */
|
|
xor %ax, %ax
|
|
mov %ax, %ds
|
|
lidt __realmode_idt
|
|
|
|
.endm
|
|
|
|
.macro prepare_for_irom
|
|
movl $0x1000, %eax
|
|
movl %eax, %esp
|
|
|
|
/* Initialise registers for option rom lcall */
|
|
movl __registers + 0, %eax
|
|
movl __registers + 4, %ebx
|
|
movl __registers + 8, %ecx
|
|
movl __registers + 12, %edx
|
|
movl __registers + 16, %esi
|
|
movl __registers + 20, %edi
|
|
|
|
/* Set all segments to 0x0000, ds to 0x0040 */
|
|
push %ax
|
|
xor %ax, %ax
|
|
mov %ax, %es
|
|
mov %ax, %fs
|
|
mov %ax, %gs
|
|
mov SEG(X86_GDT_ENTRY_16BIT_FLAT_DS), %ax
|
|
mov %ax, %ds
|
|
pop %ax
|
|
|
|
.endm
|
|
|
|
.macro enter_protected_mode
|
|
/* Go back to protected mode */
|
|
movl %cr0, %eax
|
|
orl $X86_CR0_PE, %eax
|
|
movl %eax, %cr0
|
|
|
|
/* Now that we are in protected mode jump to a 32 bit code segment */
|
|
data32 ljmp SEG(X86_GDT_ENTRY_32BIT_CS), $PTR_TO_REAL_MODE(1f)
|
|
1:
|
|
.code32
|
|
mov SEG(X86_GDT_ENTRY_32BIT_DS), %ax
|
|
mov %ax, %ds
|
|
mov %ax, %es
|
|
mov %ax, %gs
|
|
mov %ax, %ss
|
|
mov SEG(X86_GDT_ENTRY_32BIT_FS), %ax
|
|
mov %ax, %fs
|
|
|
|
/* restore proper idt */
|
|
lidt idt_ptr
|
|
.endm
|
|
|
|
/*
|
|
* In order to be independent of U-Boot's position in RAM we relocate a part
|
|
* of the code to the first megabyte of RAM, so the CPU can use it in
|
|
* real-mode. This code lives at asm_realmode_code.
|
|
*/
|
|
.globl asm_realmode_code
|
|
asm_realmode_code:
|
|
|
|
/* Realmode IDT pointer structure. */
|
|
__realmode_idt = PTR_TO_REAL_MODE(.)
|
|
.word 1023 /* 16 bit limit */
|
|
.long 0 /* 24 bit base */
|
|
.word 0
|
|
|
|
/* Preserve old stack */
|
|
__stack = PTR_TO_REAL_MODE(.)
|
|
.long 0
|
|
|
|
/* Register store for realmode_call and realmode_interrupt */
|
|
__registers = PTR_TO_REAL_MODE(.)
|
|
.long 0 /* 0 - EAX */
|
|
.long 0 /* 4 - EBX */
|
|
.long 0 /* 8 - ECX */
|
|
.long 0 /* 12 - EDX */
|
|
.long 0 /* 16 - ESI */
|
|
.long 0 /* 20 - EDI */
|
|
|
|
/* 256 byte buffer, used by int10 */
|
|
.globl asm_realmode_buffer
|
|
asm_realmode_buffer:
|
|
.skip 256
|
|
|
|
.code32
|
|
.globl asm_realmode_call
|
|
asm_realmode_call:
|
|
/* save all registers to the stack */
|
|
pusha
|
|
pushf
|
|
movl %esp, __stack
|
|
movl %esp, %ebp
|
|
|
|
/*
|
|
* This function is called with regparm=0 and we have to skip the
|
|
* 36 bytes from pushf+pusha. Hence start at 40.
|
|
* Set up our call instruction.
|
|
*/
|
|
movl 40(%ebp), %eax
|
|
mov %ax, __lcall_instr + 1
|
|
andl $0xffff0000, %eax
|
|
shrl $4, %eax
|
|
mov %ax, __lcall_instr + 3
|
|
|
|
wbinvd
|
|
|
|
setup_registers
|
|
enter_real_mode
|
|
prepare_for_irom
|
|
|
|
__lcall_instr = PTR_TO_REAL_MODE(.)
|
|
.byte 0x9a
|
|
.word 0x0000, 0x0000
|
|
|
|
enter_protected_mode
|
|
|
|
/* restore stack pointer, eflags and register values and exit */
|
|
movl __stack, %esp
|
|
popf
|
|
popa
|
|
ret
|
|
|
|
.globl __realmode_interrupt
|
|
__realmode_interrupt:
|
|
/* save all registers to the stack and store the stack pointer */
|
|
pusha
|
|
pushf
|
|
movl %esp, __stack
|
|
movl %esp, %ebp
|
|
|
|
/*
|
|
* This function is called with regparm=0 and we have to skip the
|
|
* 36 bytes from pushf+pusha. Hence start at 40.
|
|
* Prepare interrupt calling code.
|
|
*/
|
|
movl 40(%ebp), %eax
|
|
movb %al, __intXX_instr + 1 /* intno */
|
|
|
|
setup_registers
|
|
enter_real_mode
|
|
prepare_for_irom
|
|
|
|
__intXX_instr = PTR_TO_REAL_MODE(.)
|
|
.byte 0xcd, 0x00 /* This becomes intXX */
|
|
|
|
enter_protected_mode
|
|
|
|
/* restore stack pointer, eflags and register values and exit */
|
|
movl __stack, %esp
|
|
popf
|
|
popa
|
|
ret
|
|
|
|
/*
|
|
* This is the 16-bit interrupt entry point called by the IDT stub code.
|
|
*
|
|
* Before this code code is called, %eax is pushed to the stack, and the
|
|
* interrupt number is loaded into %al. On return this function cleans up
|
|
* for its caller.
|
|
*/
|
|
.code16
|
|
__interrupt_handler_16bit = PTR_TO_REAL_MODE(.)
|
|
push %ds
|
|
push %es
|
|
push %fs
|
|
push %gs
|
|
|
|
/* Save real mode SS */
|
|
movw %ss, %cs:__realmode_ss
|
|
|
|
/* Clear DF to not break ABI assumptions */
|
|
cld
|
|
|
|
/*
|
|
* Clean up the interrupt number. We could do this in the stub, but
|
|
* it would cost two more bytes per stub entry.
|
|
*/
|
|
andl $0xff, %eax
|
|
pushl %eax /* ... and make it the first parameter */
|
|
|
|
enter_protected_mode
|
|
|
|
/*
|
|
* Now we are in protected mode. We need compute the right ESP based
|
|
* on saved real mode SS otherwise interrupt_handler() won't get
|
|
* correct parameters from the stack.
|
|
*/
|
|
movzwl %cs:__realmode_ss, %ecx
|
|
shll $4, %ecx
|
|
addl %ecx, %esp
|
|
|
|
/* Call the C interrupt handler */
|
|
movl $interrupt_handler, %eax
|
|
call *%eax
|
|
|
|
/* Restore real mode ESP based on saved SS */
|
|
movzwl %cs:__realmode_ss, %ecx
|
|
shll $4, %ecx
|
|
subl %ecx, %esp
|
|
|
|
enter_real_mode
|
|
|
|
/* Restore real mode SS */
|
|
movw %cs:__realmode_ss, %ss
|
|
|
|
/*
|
|
* Restore all registers, including those manipulated by the C
|
|
* handler
|
|
*/
|
|
popl %eax
|
|
pop %gs
|
|
pop %fs
|
|
pop %es
|
|
pop %ds
|
|
popal
|
|
iret
|
|
|
|
__realmode_ss = PTR_TO_REAL_MODE(.)
|
|
.word 0
|
|
|
|
.globl asm_realmode_code_size
|
|
asm_realmode_code_size:
|
|
.long . - asm_realmode_code
|