BITS 16

%include "macrosimpresion.mac"
%include "macrosmodoreal.mac"
;%include "macrosmodoprotegido.mac"

%define KORG 0x1200
%define ADDRESS_PD 0x00100000
%define ADDRESS_PT 0x00101000
%define BASE_PILA 0x18000

global start
global imprimir_texto
global llenar_pantalla

extern tsss
extern gdt
extern GDT_DESC
extern IDT_DESC
extern inicializar_idt
extern resetear_pic
extern habilitar_pic
extern deshabilitar_pic

extern inicializar_dir_kernel

;Aca arranca todo, en el primer byte.
start:
        cli ;no me interrumpan por ahora
        ;xchg bx, bx
        jmp bienvenida

;aca ponemos todos los mensajes
iniciando: db 'Iniciando el kernel...'
iniciando_len equ $ - iniciando

bienvenida:

        IMPRIMIR_MODO_REAL iniciando, iniciando_len, 0x07, 0, 0

        ;Habilitar A20
        call habilitar_A20

        ;Deshabilitar las interrupciones
        cli

        ;Pasar a modo protegido
        lgdt [GDT_DESC]

        ;Prendo el bit para modo protegido
        mov eax, cr0
        or eax,1
        mov cr0,eax

        ;Pego el salto
        jmp 0x30:modo_protegido
BITS 32
modo_protegido:
        ;Cargar segmentos.
        xor ax,ax
        xchg bx,bx
        ;El selector en 0x20 es el de datos
        mov ax, 0x20
        mov ds, ax
        mov es, ax
        mov ss, ax

        ;El selector en 0x10 es el de video
        mov ax, 0x10
        mov fs, ax

        ;Seteo la pila de kernel
        mov esp, BASE_PILA
        mov ebp, BASE_PILA

        ;Listo, imprimamos
        call imprimir_pantalla

        ;Inicializar la IDT
        call inicializar_idt
        lidt [IDT_DESC]

        ;BOOOOOOOOOOOOOOOOMM!!!!
        ;mov dword [fs : 0xFFFFFFFF], 172
        ;xchg bx,bx

;       xchg bx,bx
;       mov eax, 0x0
;       mov ebx, 0x0
;       div bx

        ;Habilitar paginacion

        ;Armar estructuras
        xchg bx,bx
        call inicializar_dir_kernel
;       mov ecx, 1024
;       mov ebx, ADDRESS_PD

;       .loadPd:
;           mov dword [ebx+ecx*4], 0x00000002
;       loop .loadPd

;       mov dword [ADDRESS_PD], ADDRESS_PT + 0x3

;       mov ecx, 1024
;       mov ebx, ADDRESS_PT
;       mov edx, 0x1000 * 1024
;       .loadPt:
;           mov dword [ebx+ecx*4],edx
;           add dword [ebx+ecx*4], 0x00000003
;           sub edx, 0x1000
;       loop .loadPt

        xchg bx,bx
        mov dword [ADDRESS_PT+512*4], 0x000B8003

        ;Iniciar paging
        mov eax, cr3
        mov eax, ADDRESS_PD
        mov cr3, eax
        mov eax, cr0
        or eax, 0x80000000
        mov cr0, eax

        mov edi, 0x200000
        mov esi, nombre_grupo
        mov ecx, nombre_grupo_len
        mov ah, 0x70

        call imprimir_texto_paginacion

        call resetear_pic
        call habilitar_pic

        sti
        ;Inicializar el scheduler de tareas

        ;Construir tarea idle

        ;Construir primer worm

        ;Saltar a la primer tarea

        jmp $

llenar_pantalla:
    push edx
    push es
    mov dx, fs
    mov es, dx
    rep stosw
    pop es
    pop edx
    ret

imprimir_texto:
.imprimir_texto:
    mov al, [ds: ebx + edx]
    mov [fs:edi], ax
    inc edx
    add edi,2
    loop .imprimir_texto
    ret

imprimir_texto_paginacion:
.imprimir_texto_paginacion:
    mov al, [esi+edx]
    mov [edi+2*edx], ax
    inc edx
    loop .imprimir_texto_paginacion
    ret

imprimir_pantalla:
    ;Vamos a imprimir a ver que pasa
    xor edi, edi
    xor edx, edx
    xor eax, eax

    mov ecx, PIXELS_PANTALLA ;Todo el buffer.

;Llena la pantalla sin loops :D
    call llenar_pantalla

;Pongo la primer linea en blanco
    mov ax, 0x7F00
    xor edi, edi
    mov ecx, PIXELS_LINEA

    call llenar_pantalla

    mov edi, BYTES_PANTALLA
    sub edi, BYTES_LINEA
    mov ecx, PIXELS_LINEA

;Pongo la ultima linea en blanco
    call llenar_pantalla

;Imprimo el 0123456789
    xor eax, eax
    xor edx, edx
    mov edi, BYTES_LINEA
    ;Saco el espacio para que entre
    mov ebx, protegido
    sub edi, protegido_len
    sub edi, protegido_len
    mov ecx, protegido_len
    mov ah, 0x70

    call imprimir_texto
    ret

protegido: db '0123456789'
protegido_len equ $ - protegido

nombre_grupo: db 'Siddharta Kiwi'
nombre_grupo_len equ $ - nombre_grupo

%include "a20.asm"