//----------------------------------------------------------------------------//
//                                OS on Kaleid                                //
//                                                                            //
//  Desc:         GDT related functions                                       //
//                                                                            //
//                                                                            //
//  Copyright © 2018-2020 The OS/K Team                                       //
//                                                                            //
//  This file is part of OS/K.                                                //
//                                                                            //
//  OS/K 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         //
//  any later version.                                                        //
//                                                                            //
//  OS/K 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 OS/K.  If not, see <https://www.gnu.org/licenses/>.            //
//----------------------------------------------------------------------------//

#include <mm/gdt.h>
#include <mm/paging.h>
#include <init/boot.h>

GdtPtr_t gdtPtr;
GdtEntry_t gdt[4] __attribute__((__aligned__(KPAGESIZE)));
TssDescriptor_t tssDesc __attribute__((__aligned__(KPAGESIZE)));
Tss_t tss __attribute__((__aligned__(KPAGESIZE)));

void MmInitGdt(void)
{
    ushort tssOffset = (ushort)((ulong)(&gdt[2]) - (ulong)(&gdt[0]));

    gdtPtr.base = (ulong)&gdt[0];
    gdtPtr.limit = sizeof(gdt) - 1;

    memzero((void *)&gdt[0], sizeof(gdt));
    memzero((void *)&tssDesc, sizeof(tssDesc));
    memzero((void *)&tss, sizeof(tss));

    gdt[1].lowLimit     = 0xFFFF;
    gdt[1].access       = 0x98;
    gdt[1].flags        = 0x20;

    gdt[2].lowLimit     = 0xFFFF;
    gdt[2].access       = 0x98;
    gdt[2].flags        = 0x20;

    tssDesc.access          = 0x89;
    tssDesc.flags           = 0x40;
    tssDesc.lowBase         = (ulong)&tss & 0xFFFF;
    tssDesc.middleBase      = ((ulong)&tss >> 16) & 0xFF;
    tssDesc.highBase        = ((ulong)&tss >> 24) & 0xFF;
    tssDesc.veryHighBase    = ((ulong)&tss >> 32) & 0xFFFFFFFF;
    tssDesc.lowLimit        = sizeof(tss);

    tss.ist1 = (ulong)memalign(4*MB, 4*KB) + 4*MB;  // ISR RESCUE STACK
    tss.ist2 = (ulong)memalign(4*MB, 4*KB) + 4*MB;  // ISR STACK
    tss.ist3 = (ulong)memalign(4*MB, 4*KB) + 4*MB;  // ISR STACK
    tss.iomap_base = sizeof(tss);

    DebugLog("ISR Stacks initialized : Rescue %p, Normal %p, %p\n",
            tss.ist1,
            tss.ist2,
            tss.ist3);

    memmove(&gdt[2], &tssDesc, sizeof(TssDescriptor_t));

    DebugLog("TSS setting up :\n"
             "gdt[0]        %#x\n"
             "gdt[2]        %#x\n"
             "access :      %#x\n"
             "flags  :      %#x\n"
             "lowBase  :    %#x\n"
             "middleBase  : %#x\n"
             "highBase  :   %#x\n"
             "veryHighBase: %#x\n"
             "lowLimit  :   %#x\n"
             "ist  :        %#x\n"
             "iomap_base  : %#x\n"
             "offset  :     %#x\n",
             &gdt[0],
             &gdt[2],
             tssDesc.access,
             tssDesc.flags,
             tssDesc.lowBase,
             tssDesc.middleBase,
             tssDesc.highBase,
             tssDesc.veryHighBase,
             tssDesc.lowLimit,
             tss.ist1,
             tss.iomap_base,
             tssOffset
    );

    MmLoadGdt(&gdtPtr, tssOffset);
}