	.globl	entry, __switch_context, __exit_context, halt, init_exceptions

	.text
	.align	4

/*
 * Entry point
 * We start execution from here.
 * It is assumed that CPU is in 32-bit protected mode and
 * all segments are 4GB and base zero (flat model).
 */
entry:
	/* Save boot context and switch to our main context.
	 * Main context is statically defined in C.
	 */
	pushl	%cs
	call	__switch_context

	/* We get here when the main context switches back to
	 * the boot context.
	 * Return to previous bootloader.
	 */
	ret

/*
 * Switch execution context
 * This saves registers, segments, and GDT in the stack, then
 * switches the stack, and restores everything from the new stack.
 * This function takes no argument. New stack pointer is
 * taken from global variable __context, and old stack pointer
 * is also saved to __context. This way we can just jump to
 * this routine to get back to the original context.
 *
 * Call this routine with lcall or pushl %cs; call.
 */
__switch_context:
	/* Save everything in current stack */
	pushfl		    /* 56 */
	pushl	%ds	    /* 52 */
	pushl	%es	    /* 48 */
	pushl	%fs	    /* 44 */
	pushl	%gs	    /* 40 */
	pushal		    /* 8 */
	subl	$8, %esp
	movw	%ss, (%esp) /* 0 */
	sgdt	2(%esp)	    /* 2 */

#if 0
	/* Swap %cs and %eip on the stack, so lret will work */
	movl	60(%esp), %eax
	xchgl	%eax, 64(%esp)
	movl	%eax, 60(%esp)
#endif

	/* At this point we don't know if we are on flat segment
	 * or relocated. So compute the address offset from %eip.
	 * Assuming CS.base==DS.base==SS.base.
	 */
	call	1f
1:	popl	%ebx
	subl	$1b, %ebx

	/* Interrupts are not allowed... */
	cli

	/* Current context pointer is our stack pointer */
	movl	%esp, %esi

	/* Normalize the ctx pointer */
	subl	%ebx, %esi

	/* Swap it with new value */
	xchgl	%esi, __context(%ebx)

	/* Adjust new ctx pointer for current address offset */
	addl	%ebx, %esi

	/* Load new %ss and %esp to temporary */
	movzwl	(%esi), %edx
	movl	20(%esi), %eax

	/* Load new GDT */
	lgdt	2(%esi)

	/* Load new stack segment with new GDT */
	movl	%edx, %ss

	/* Set new stack pointer, but we have to adjust it because
	 * pushal saves %esp value before pushal, and we want the value
	 * after pushal.
	 */
	leal	-32(%eax), %esp

	/* Load the rest from new stack */
	popal
	popl	%gs
	popl	%fs
	popl	%es
	popl	%ds
	popfl

	/* Finally, load new %cs and %eip */
	lret

__exit_context:
	/* Get back to the original context */
	pushl	%cs
	call	__switch_context

	/* We get here if the other context attempt to switch to this
	 * dead context. This should not happen. */

halt:
	cli
	hlt
	jmp	halt

/*
 * initialize exception handler. All exceptions end up in the same
 * C function.
 */

init_exceptions:
	pushl	%ebx
	pushl	%edi

        /* Initialize the Interrupt Descriptor table */
        leal    _idt, %edi
        leal    vec0, %ebx
        movl    $(0x08 << 16), %eax     /* cs selector */

1:      movw    %bx, %ax
        movl    %ebx, %edx
        movw    $0x8E00, %dx            /* Interrupt gate - dpl=0, present */
        movl    %eax, 0(%edi)
        movl    %edx, 4(%edi)
        addl    $6, %ebx
        addl    $8, %edi
        cmpl    $_idt_end, %edi
        jne     1b

        /* Load the Interrupt descriptor table */
        lidt    idtarg

	movl 	$0, %eax
	popl	%edi
	popl	%ebx
	ret

vec0:
        pushl   $0 /* error code */
        pushl   $0 /* vector */
        jmp int_hand
vec1:
        pushl   $0 /* error code */
        pushl   $1 /* vector */
        jmp int_hand

vec2:
        pushl   $0 /* error code */
        pushl   $2 /* vector */
        jmp int_hand

vec3:
        pushl   $0 /* error code */
        pushl   $3 /* vector */
        jmp     int_hand

vec4:
        pushl   $0 /* error code */
        pushl   $4 /* vector */
        jmp     int_hand

vec5:
        pushl   $0 /* error code */
        pushl   $5 /* vector */
        jmp     int_hand

vec6:
        pushl   $0 /* error code */
        pushl   $6 /* vector */
        jmp     int_hand
vec7:
        pushl   $0 /* error code */
        pushl   $7 /* vector */
        jmp     int_hand

vec8:
        /* error code */
        pushl   $8 /* vector */
        jmp     int_hand
        .word   0x9090

vec9:
        pushl   $0 /* error code */
        pushl   $9 /* vector */
        jmp int_hand

vec10:
        /* error code */
        pushl   $10 /* vector */
        jmp     int_hand
        .word   0x9090

vec11:
        /* error code */
        pushl   $11 /* vector */
        jmp     int_hand
        .word   0x9090

vec12:
        /* error code */
        pushl   $12 /* vector */
        jmp     int_hand
        .word   0x9090

vec13:
        /* error code */
        pushl   $13 /* vector */
        jmp     int_hand
        .word   0x9090

vec14:
        /* error code */
        pushl   $14 /* vector */
        jmp     int_hand
        .word   0x9090

vec15:
        pushl   $0 /* error code */
        pushl   $15 /* vector */
        jmp     int_hand

vec16:
        pushl   $0 /* error code */
        pushl   $16 /* vector */
        jmp     int_hand

vec17:
        /* error code */
        pushl   $17 /* vector */
        jmp     int_hand
        .word   0x9090

vec18:
        pushl   $0 /* error code */
        pushl   $18 /* vector */
        jmp     int_hand

vec19:
        pushl   $0 /* error code */
        pushl   $19 /* vector */
        jmp     int_hand

__divide_error:
        pushl   $0 /* error code */
        pushl   $20 /* vector */
        jmp     int_hand
        .global __divide_error

int_hand:
        /* At this point on the stack there is:
         *  0(%esp) vector
         *  4(%esp) error code
         *  8(%esp) eip
         * 12(%esp) cs
         * 16(%esp) eflags
         */
        pushl   %edi
        pushl   %esi
        pushl   %ebp
        /* Original stack pointer */
        leal    32(%esp), %ebp
        pushl   %ebp
        pushl   %ebx
        pushl   %edx
        pushl   %ecx
        pushl   %eax

        pushl   %esp    /* Pointer to structure on the stack */

        call    x86_exception
        pop     %eax    /* Drop the pointer */

        popl    %eax
        popl    %ecx
        popl    %edx
        popl    %ebx
        popl    %ebp /* Ignore saved %esp value */
        popl    %ebp
        popl    %esi
        popl    %edi

        addl    $8, %esp /* pop of the vector and error code */

        iret

idtarg:
        .word   _idt_end - _idt - 1     /* limit */
        .long   _idt
        .word   0
_idt:
        .fill   20, 8, 0        # idt is unitiailzed
_idt_end:

        .globl  arch_nvram_size, arch_nvram_get, arch_nvram_put
arch_nvram_size:
        xor     %eax, %eax
        ret

arch_nvram_get:
        ret

arch_nvram_put:
        ret