/* * From coreboot x86_asm.S, cleaned up substantially * * Copyright (C) 2009-2010 coresystems GmbH * * SPDX-License-Identifier: GPL-2.0 */ #include #include #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