backported fixes from 256boss

[bootcensus] / src / lowcode.s

# pcboot - bootable PC demo/game kernel
# Copyright (C) 2018-2019  John Tsiombikas <nuclear@member.fsf.org>
#
# 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, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

        .section .lowtext,"ax"

        .code32
        .align 4
        # place to save the protected mode IDTR pseudo-descriptor
        # with sidt, so that it can be restored before returning
        .short 0
saved_idtr:
idtlim: .short 0
idtaddr:.long 0
        # real mode IDTR pseudo-descriptor pointing to the IVT at addr 0
        .short 0
rmidt:  .short 0x3ff
        .long 0

saved_esp: .long 0
saved_ebp: .long 0
saved_eax: .long 0
saved_es: .word 0
saved_ds: .word 0
saved_flags: .word 0
saved_if: .byte 0
saved_pic1_mask: .byte 0
saved_pic2_mask: .byte 0

        # drop back to unreal mode to call 16bit interrupt
        .global int86
int86:
        push %ebp
        mov %esp, %ebp
        pushal
        call get_intr_flag
        mov %al, saved_if
        cli
        # save protected mode IDTR and replace it with the real mode vectors
        sidt (saved_idtr)
        lidt (rmidt)

        # save PIC masks
        pushl $0
        call get_pic_mask
        add $4, %esp
        mov %al, saved_pic1_mask
        pushl $1
        call get_pic_mask
        add $4, %esp
        mov %al, saved_pic2_mask

        # modify the int instruction. do this here before the
        # cs-load jumps, to let them flush the instruction cache
        mov $int_op, %ebx
        movb 8(%ebp), %al
        movb %al, 1(%ebx)

        # long jump to load code selector for 16bit code (6)
        ljmp $0x30,$0f
0:
        .code16
        # disable protection
        mov %cr0, %eax
        and $0xfffe, %ax
        mov %eax, %cr0
        # load cs <- 0
        ljmp $0,$0f
0:      # zero data segments
        xor %ax, %ax
        mov %ax, %ds
        mov %ax, %es
        mov %ax, %ss
        mov %ax, %fs
        mov %ax, %gs
        nop

        # load registers from the int86regs struct
        # point esp to the regs struct to load registers with popa/popf
        mov %esp, saved_esp
        mov %ebp, saved_ebp
        mov 12(%ebp), %esp
        popal
        popfw
        pop %es
        pop %ds
        # ignore fs and gs for now, don't think I'm going to need them

        # move to the real-mode stack, at the top of conventional memory
        #mov $0x9000, %sp
        #mov %sp, %ss
        #mov $0, %esp

        # move to the real-mode stack, accessible from ss=0
        # just in case the BIOS call screws up our unreal mode
        mov $0x7be0, %esp

        # call 16bit interrupt
int_op: int $0
        # BIOS call might have enabled interrupts, cli for good measure
        cli

        # save all registers that we'll clobber before having the
        # chance to populate the int86regs structure
        mov %eax, saved_eax
        mov %ds, saved_ds
        mov %es, saved_es
        pushfw
        popw %ax
        mov %ax, saved_flags

        # re-enable protection
        mov %cr0, %eax
        or $1, %ax
        mov %eax, %cr0
        # long jump to load code selector for 32bit code (1)
        ljmp $0x8,$0f
0:
        .code32
        # set data selector (2) to all segment regs
        mov $0x10, %ax
        mov %ax, %ds
        mov %ax, %es
        mov %ax, %ss
        mov %ax, %fs
        mov %ax, %gs
        nop

        # point the esp to our regs struct, to fill it with pusha/pushf
        mov saved_ebp, %ebp
        mov 12(%ebp), %esp
        add $38, %esp
        mov saved_ds, %ax
        pushw %ax
        mov saved_es, %ax
        pushw %ax
        # grab the flags and replace the carry bit from the saved flags
        pushfw
        popw %ax
        and $0xfffe, %ax
        or saved_flags, %ax
        pushw %ax
        mov saved_eax, %eax
        pushal
        mov saved_esp, %esp

        # restore 32bit interrupt descriptor table
        lidt (saved_idtr)

        # restore PIC configuration
        call init_pic

        # restore IRQ masks
        movzbl saved_pic1_mask, %eax
        push %eax
        pushl $0
        call set_pic_mask
        add $8, %esp

        movzbl saved_pic2_mask, %eax
        push %eax
        pushl $1
        call set_pic_mask
        add $8, %esp

        # keyboard voodoo: with some BIOS implementations, after returning from
        # int13, there's (I guess) leftover data in the keyboard port and we
        # can't receive any more keyboard interrupts afterwards. Reading from
        # the keyboard data port (60h) once, seems to resolve this. And it's
        # cheap enough, so why not... I give up.
        in $0x60, %al

        # restore interrupts to their previous state
        movzbl saved_if, %eax
        pushl %eax
        call set_intr_flag
        add $4, %esp

        popal
        pop %ebp
        ret