arch/x86/lib/bios_asm.S

/* 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