pactor64.h

/* ============================================================================

 * Pactor64 — Common Header for x86-64 Kernel

 * All types, port I/O, and function declarations

 * ============================================================================ */

#ifndef PACTOR64_H

#define PACTOR64_H

/* === Type Definitions === */

typedef unsigned char      uint8_t;

typedef unsigned short     uint16_t;

typedef unsigned int       uint32_t;

typedef unsigned long      uint64_t;

typedef signed char        int8_t;

typedef signed short       int16_t;

typedef signed int         int32_t;

typedef signed long        int64_t;

typedef unsigned long      size_t;

typedef signed long        ssize_t;

typedef unsigned long      uintptr_t;

#define NULL ((void *)0)

#define true  1

#define false 0

#define asm __asm__ volatile

/* === GCC Built-in va_list === */

typedef __builtin_va_list va_list;

#define va_start(v,l) __builtin_va_start(v,l)

#define va_end(v)     __builtin_va_end(v)

#define va_arg(v,t)   __builtin_va_arg(v,t)

/* === Port I/O === */

static inline void outb(uint16_t port, uint8_t val) {

    __asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));

}

static inline uint8_t inb(uint16_t port) {

    uint8_t val;

    __asm__ volatile ("inb %1, %0" : "=a"(val) : "Nd"(port));

    return val;

}

static inline void outw(uint16_t port, uint16_t val) {

    __asm__ volatile ("outw %0, %1" : : "a"(val), "Nd"(port));

}

static inline uint16_t inw(uint16_t port) {

    uint16_t val;

    __asm__ volatile ("inw %1, %0" : "=a"(val) : "Nd"(port));

    return val;

}

static inline void io_wait(void) {

    outb(0x80, 0);

}

static inline void cli(void) {

    __asm__ volatile ("cli");

}

static inline void sti(void) {

    __asm__ volatile ("sti");

}

static inline void hlt(void) {

    __asm__ volatile ("hlt");

}

/* === Serial (COM1) === */

#define COM1 0x3F8

void serial_init(void);

void serial_putc(char c);

void serial_puts(const char *s);

int  serial_getc(void);

int  serial_poll(void);

void serial_print_hex(uint64_t val);

void serial_print_dec(uint64_t val);

void kprintf(const char *fmt, ...);

/* === String Utilities (no libc) === */

int    kstrcmp(const char *a, const char *b);

int    kstrncmp(const char *a, const char *b, size_t n);

size_t kstrlen(const char *s);

void  *kmemset(void *dst, int c, size_t n);

void  *kmemcpy(void *dst, const void *src, size_t n);

/* === IDT === */

struct idt_entry {

    uint16_t offset_low;

    uint16_t selector;

    uint8_t  ist;

    uint8_t  type_attr;

    uint16_t offset_mid;

    uint32_t offset_high;

    uint32_t reserved;

} __attribute__((packed));

struct idtr {

    uint16_t limit;

    uint64_t base;

} __attribute__((packed));

typedef struct {

    uint64_t r15, r14, r13, r12, r11, r10, r9, r8;

    uint64_t rbp, rdi, rsi, rdx, rcx, rbx, rax;

    uint64_t int_no, err_code;

    /* Pushed by CPU */

    uint64_t rip, cs, rflags, rsp, ss;

} registers_t;

/* From isr.asm */

extern uint64_t isr_stub_table[256];

extern void idt_load(struct idtr *idtr);

void idt_init(void);

void isr_dispatch(registers_t *regs);

/* === PIC === */

#define PIC1_CMD   0x20

#define PIC1_DATA  0x21

#define PIC2_CMD   0xA0

#define PIC2_DATA  0xA1

#define PIC_EOI    0x20

void pic_remap(int offset1, int offset2);

void pic_mask_all(void);

void pic_unmask_irq(int irq);

void pic_send_eoi(int irq);

/* === Timer (PIT) === */

void     timer_init(uint32_t hz);

uint64_t timer_get_ticks(void);

uint64_t timer_get_seconds(void);

/* === Keyboard === */

#define KBD_DATA_PORT 0x60

#define KBD_STATUS_PORT 0x64

void keyboard_init(void);

int  keyboard_getchar(void);

/* === Physical Memory Manager (bitmap) === */

void     pmm_init(uint64_t mb2_info);

void    *pmm_alloc_page(void);

void     pmm_free_page(void *page);

uint64_t pmm_get_free_pages(void);

uint64_t pmm_get_total_pages(void);

/* === Kernel Heap === */

#define HEAP_SIZE (8 * 1024 * 1024)  /* 8 MB */

void  heap_init(void);

void *kmalloc(size_t size);

void *kcalloc(size_t count, size_t size);

void  kfree(void *ptr);

/* === VGA Text Mode === */

#define VGA_BUFFER 0xB8000

#define VGA_WIDTH  80

#define VGA_HEIGHT 25

void vga_init(void);

void vga_clear(void);

void vga_putc(char c);

void vga_puts(const char *s);

void vga_printf(const char *fmt, ...);

/* === Shell === */

void shell_init(void);

void shell_run(void);

/* === ATA PIO Block Device === */

#define ATA_DATA        0x1F0

#define ATA_ERROR       0x1F1

#define ATA_FEATURES    0x1F1

#define ATA_SECCOUNT    0x1F2

#define ATA_LBA_LO      0x1F3

#define ATA_LBA_MID     0x1F4

#define ATA_LBA_HI      0x1F5

#define ATA_DRIVE_HEAD  0x1F6

#define ATA_STATUS      0x1F7

#define ATA_COMMAND     0x1F7

#define ATA_ALT_STATUS  0x3F6

#define ATA_DEV_CTRL    0x3F6

void     ata_init(void);

int      ata_read_sectors(uint32_t lba, uint32_t count, void *buf);

int      ata_write_sectors(uint32_t lba, uint32_t count, const void *buf);

int      ata_is_present(void);

uint32_t ata_get_sector_count(void);

const char *ata_get_model(void);

const char *ata_get_serial(void);

int      ata_block_read(uint64_t lba, uint32_t count, void *buf);

/* === Multiboot2 Structures === */

struct mb2_tag {

    uint32_t type;

    uint32_t size;

} __attribute__((packed));

struct mb2_mmap_entry {

    uint64_t base_addr;

    uint64_t length;

    uint32_t type;

    uint32_t zero;

} __attribute__((packed));

struct mb2_tag_mmap {

    uint32_t type;

    uint32_t size;

    uint32_t entry_size;

    uint32_t entry_version;

    struct mb2_mmap_entry entries[];

} __attribute__((packed));

/* === Linker-defined symbols === */

extern char kernel_end[];

#endif /* PACTOR64_H */