diff --git a/Makefile b/Makefile index 9d78640..24dba1d 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ CC = ${HOME}/opt/cross/bin/i686-elf-gcc CPP = ${HOME}/opt/cross/bin/i686-elf-g++ CFLAGS = -ffreestanding -Og -ggdb -Wall -Wextra -OFILES =$(BUILD_DIR)/boot.o $(BUILD_DIR)/kterm.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/memory.o $(BUILD_DIR)/paging.o $(BUILD_DIR)/pit.o $(BUILD_DIR)/time.o $(BUILD_DIR)/keyboard.o $(BUILD_DIR)/io.o $(BUILD_DIR)/gdtc.o $(BUILD_DIR)/idt.o $(BUILD_DIR)/pic.o $(BUILD_DIR)/sv-terminal.o $(BUILD_DIR)/string.o $(BUILD_DIR)/prekernel.o $(BUILD_DIR)/cpu.o $(BUILD_DIR)/KHeap.o +OFILES =$(BUILD_DIR)/boot.o $(BUILD_DIR)/kterm.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/memory.o $(BUILD_DIR)/paging.o $(BUILD_DIR)/pit.o $(BUILD_DIR)/time.o $(BUILD_DIR)/keyboard.o $(BUILD_DIR)/io.o $(BUILD_DIR)/gdtc.o $(BUILD_DIR)/idt.o $(BUILD_DIR)/pic.o $(BUILD_DIR)/sv-terminal.o $(BUILD_DIR)/string.o $(BUILD_DIR)/prekernel.o $(BUILD_DIR)/cpu.o $(BUILD_DIR)/KHeap.o $(BUILD_DIR)/pci.o $(BUILD_DIR)/pcidevice.o $(BUILD_DIR)/atapiDevice.o $(BUILD_DIR)/ataDevice.o $(BUILD_DIR)/rsdp.o SRC_DIR = source BUILD_DIR = build @@ -32,13 +32,19 @@ iso: clean_iso clean build cp build/myos.bin root/boot/myos.bin cp source/grub.cfg root/boot/grub/grub.cfg grub-mkrescue -o build/barinkOS.iso root - run: all - $(EMULATOR) -cdrom build/barinkOS.iso -serial stdio -vga std -display gtk -m 2G -cpu core2duo - + virtualboxvm --startvm "BarinkOS_test" debug: all objcopy --only-keep-debug build/myos.bin kernel.sym $(EMULATOR) -cdrom build/barinkOS.iso -serial stdio -vga std -display gtk -m 2G -cpu core2duo -s -d int +test: + $(EMULATOR) -kernel $(BUILD_DIR)/myos.bin -serial stdio -vga std -display gtk -m 2G -cpu core2duo + +test_iso: + $(EMULATOR) -boot d -cdrom $(BUILD_DIR)/barinkOS.iso -serial stdio -vga std -display gtk -m 2G -cpu core2duo +test_disk: + $(EMULATOR) -boot d -drive format=raw,file=build/disk.img -serial stdio -vga std -display gtk -m 2G -cpu core2duo + build_kernel: $(OBJ_LINK_LIST) $(CC) -T $(SRC_DIR)/kernel//linker.ld -o $(BUILD_DIR)/myos.bin \ @@ -59,7 +65,7 @@ $(BUILD_DIR)/kterm.o: $(CPP) -c $(SRC_DIR)/kernel/terminal/kterm.cpp -o $(BUILD_DIR)/kterm.o $(CFLAGS) -fno-exceptions -fno-rtti $(BUILD_DIR)/io.o: - $(CPP) -c $(SRC_DIR)/kernel/io.cpp -o $(BUILD_DIR)/io.o $(CFLAGS) -fno-exceptions -fno-rtti + $(CPP) -c $(SRC_DIR)/kernel/drivers/io/io.cpp -o $(BUILD_DIR)/io.o $(CFLAGS) -fno-exceptions -fno-rtti $(BUILD_DIR)/idt.o: $(CPP) -c $(SRC_DIR)/kernel/interrupts/idt/idt.cpp -o $(BUILD_DIR)/idt.o $(CFLAGS) -fno-exceptions -fno-rtti @@ -71,11 +77,30 @@ $(BUILD_DIR)/pic.o: $(CPP) -c $(SRC_DIR)/kernel/drivers/pic/pic.cpp -o $(BUILD_DIR)/pic.o $(CFLAGS) -fno-exceptions -fno-rtti $(BUILD_DIR)/string.o: - $(CPP) -c $(SRC_DIR)/kernel/lib/string.cpp -o $(BUILD_DIR)/string.o $(CFLAGS) -fno-exceptions -fno-rtti + $(CC) -c $(SRC_DIR)/lib/include/string.c -o $(BUILD_DIR)/string.o $(CFLAGS) -std=gnu99 + +$(BUILD_DIR)/PhysicalMemoryManager.o: + $(CPP) -c $(SRC_DIR)/kernel/memory/PhysicalMemoryManager.cpp -o $(BUILD_DIR)/PhysicalMemoryManager.o $(CFLAGS) -fno-exceptions -fno-rtti + +$(BUILD_DIR)/pci.o: + $(CPP) -c $(SRC_DIR)/kernel/drivers/pci/pci.cpp -o $(BUILD_DIR)/pci.o $(CFLAGS) -fno-exceptions -fno-rtti + +$(BUILD_DIR)/pcidevice.o: + $(CPP) -c $(SRC_DIR)/kernel/drivers/pci/pciDevice.cpp -o $(BUILD_DIR)/pcidevice.o $(CFLAGS) -fno-exceptions -fno-rtti + +$(BUILD_DIR)/atapiDevice.o: + $(CPP) -c $(SRC_DIR)/kernel/drivers/atapi/atapiDevice.cpp -o $(BUILD_DIR)/atapiDevice.o $(CFLAGS) -fno-exceptions -fno-rtti + +$(BUILD_DIR)/ataDevice.o: + $(CPP) -c $(SRC_DIR)/kernel/drivers/ata/ataDevice.cpp -o $(BUILD_DIR)/ataDevice.o $(CFLAGS) -fno-exceptions -fno-rtti + +$(BUILD_DIR)/rsdp.o: + $(CPP) -c $(SRC_DIR)/kernel/drivers/acpi/rsdp.cpp -o $(BUILD_DIR)/rsdp.o $(CFLAGS) -fno-exceptions -fno-rtti $(BUILD_DIR)/pit.o: $(CPP) -c $(SRC_DIR)/kernel/drivers/pit/pit.cpp -o $(BUILD_DIR)/pit.o $(CFLAGS) -fno-exceptions -fno-rtti + $(BUILD_DIR)/keyboard.o: $(CPP) -c $(SRC_DIR)/kernel/drivers/ps-2/keyboard.cpp -o $(BUILD_DIR)/keyboard.o $(CFLAGS) -fno-exceptions -fno-rtti diff --git a/README.md b/README.md index 155afd0..2edcad6 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,14 @@ Multiboot information can be read by the kernel. ![Page faulting](screenshots/PageFault.png) \ Enabled paging and am getting page faults! +![PCI enumeration](screenshots/PCIBusEnumeration.png) \ +Enumerating the PCI bus + +![ATAPI CD-ROM Identification](screenshots/CD-ROM_Identify.png) \ +Correctly identified our ATAPI device 🎉 + +![Reading Files from FAT-16](screenshots/ReadingFilesFromFAT16.png) \ +Reading a file from a FAT-16 Formatted drive ________________________ diff --git a/features.md b/features.md index c953c7f..1d33930 100644 --- a/features.md +++ b/features.md @@ -23,6 +23,14 @@ The heap: allocating memory at runtime (malloc and free) is almost impossible to go without. \ Enable SIMD Extensions (SSE) +## Other features I am thinking of: + PCI support \ + ATA PIO Mode support \ + USTAR Filesystem ( For its simplicity this is very likely the first filesystem the OS is going to support) \ + ACPI support ( Or some other basic way to support shutdown, reboot and possibly hibernation ) \ + ATAPI support \ + Keyboard support ( P/S2 Keyboard) \ + Memory Management (MMU) Hardware Management system Preemptive multi tasking \ diff --git a/screenshots/CD-ROM_Identify.png b/screenshots/CD-ROM_Identify.png new file mode 100644 index 0000000..586d2ee --- /dev/null +++ b/screenshots/CD-ROM_Identify.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a49af346df5f591fd139ebda79fbb80e9d79b1db2697bc8e037ccc6955e69959 +size 58517 diff --git a/screenshots/PCIBusEnumeration.png b/screenshots/PCIBusEnumeration.png new file mode 100644 index 0000000..cafbf48 --- /dev/null +++ b/screenshots/PCIBusEnumeration.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3873ae8e4e291661ae99310cf26ed6b51462a3434142423b55652e63efd96c79 +size 17146 diff --git a/screenshots/ReadingFilesFromFAT16.png b/screenshots/ReadingFilesFromFAT16.png new file mode 100644 index 0000000..f203823 --- /dev/null +++ b/screenshots/ReadingFilesFromFAT16.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab26fe8f7b0d9fca81e8481a67796e93bbc2fb7369accac03a9aaecf415cd4de +size 27813 diff --git a/scripts/build.py b/scripts/build.py new file mode 100755 index 0000000..cd06dc4 --- /dev/null +++ b/scripts/build.py @@ -0,0 +1,25 @@ +#!/usr/bin/python3 +import os +import subprocess + + +print("Building BarinkOS") + + +# list and run build scripts +print("Running build-scripts") +os.chdir("scripts") + +scripts=os.listdir() +currentScript=os.path.basename(__file__) + +if currentScript in scripts: + scripts.remove(currentScript) + + +for script in scripts: + print(os.getcwd()) + print("Running:" + script) + subprocess.call(script, cwd=os.getcwd()) + +os.chdir("..") \ No newline at end of file diff --git a/scripts/create-filesystem.sh b/scripts/create-filesystem.sh new file mode 100644 index 0000000..45dc117 --- /dev/null +++ b/scripts/create-filesystem.sh @@ -0,0 +1,64 @@ +#!/bin/bash +# +# How to build a boot image +# NOTE: This script cant run properly yet +# Things described here should be done manually for now +# +# COPYRIGHT © Nigel Barink 2023 +# + +echo "Building a FAT16 filesystem" + + +su + +# dd if=/dev/zero of=diks.img bs=512 count=131072 +# fdisk disk.img +# Use the following options in fdisk (Format Disk Tool) +# We want to create a MBR (NOT GPT) Partition table containing 1 logical disk +# with a primary FAT16 partition marked bootable + +#OPTIONs + +# Create new DOS disklabel +# o +# Create new partition +# n +# Choose Primary as partition type +# p +# hit enter to choose default for the other options + +# Mark partition 1 as bootable +# a + +# Change partition type to FAT16 +# t +# Choose Partition 1 +# 1 +# Choose HEX 6 for FAT16 +# 6 + +# Sync and write changes to disk +# w + +# Create a "block" device from the disk.img +# losetup /dev/loop9 disk.img + +# Format the partition on the disk as FAT16 +# mkdosfs -F16 /dev/loop9 + +# Mount the disk to a folder on our dev machine +# mount /dev/loop9 /mnt + +# Install the grub bootloader onto the disk +# grub-install --no-floppy --modules="normal multiboot" /dev/loop9 --target=i386-pc --boot-directory=/mnt/boot --force + +# copy the necessary OS files +# cp root/boot/myos.bin /mnt/boot/myos.bin +# cp root/boot/grub/grub.cfg /mnt/boot/grub/grub.cfg + +# Unmount the device +# umount /mnt + +# Destroy the loop device +# losetup -d /dev/loop9 diff --git a/scripts/test.sh b/scripts/test.sh new file mode 100755 index 0000000..cb84bbe --- /dev/null +++ b/scripts/test.sh @@ -0,0 +1,5 @@ +#!/bin/bash +start=`date +%s` +end=`date +%s` +echo That took $((end-start)) seconds +date +"%c" -d195440409 diff --git a/source/grub.cfg b/source/grub.cfg index 30bb80f..27391d2 100644 --- a/source/grub.cfg +++ b/source/grub.cfg @@ -1,9 +1,8 @@ +GRUB_DEFAULT=0 +GRUB_TIMEOUT=-1 +GRUB_HIDDEN_TIMEOUT=0 +GRUB_HIDDEN_TIMEOUT_QUITE=true + menuentry "BarinkOS" { multiboot /boot/myos.bin } - -menuentry "BarinkOS Tests" { - multiboot /boot/myos.bin -} - - diff --git a/source/kernel-test/PhysicalMemoryManagerTest.cpp b/source/kernel-test/PhysicalMemoryManagerTest.cpp deleted file mode 100644 index 30243df..0000000 --- a/source/kernel-test/PhysicalMemoryManagerTest.cpp +++ /dev/null @@ -1,15 +0,0 @@ - -void PhysicalMemoryAllocatorTest() -{ - #ifdef UNIT_TESTS - // Small test! - void* block = allocate_block(); - void* block2 = allocate_block(); - printf("Allocated addresss 1: 0x%x 2: 0x%x\n", (uint32_t)block ,(uint32_t)block2); - free_block(block); - free_block(block2); - void* block3 = allocate_block(); - printf("Allocated addresss 3: 0x%x\n", (uint32_t)block3); - free_block(block3); - #endif -} \ No newline at end of file diff --git a/source/kernel-test/SerialTest.cpp b/source/kernel-test/SerialTest.cpp deleted file mode 100644 index cffdfc0..0000000 --- a/source/kernel-test/SerialTest.cpp +++ /dev/null @@ -1,18 +0,0 @@ - -void test_serial(){ - /** Serial test **/ - kterm_writestring("Writing to COM1 serial port:"); - init_serial(); - write_serial('A'); - write_serial('B'); - write_serial('C'); - write_serial('D'); - write_serial('E'); - - char Character_received = read_serial(); - kterm_writestring("\n"); - kterm_writestring("received from COM 1: \n"); - kterm_put(Character_received); - - kterm_writestring("\n"); -} \ No newline at end of file diff --git a/source/kernel/PartitionTable/MBR/MasterBootRecord.h b/source/kernel/PartitionTable/MBR/MasterBootRecord.h new file mode 100644 index 0000000..a8d7aea --- /dev/null +++ b/source/kernel/PartitionTable/MBR/MasterBootRecord.h @@ -0,0 +1,11 @@ +#pragma once +#include +#include "PartitionTableEntry.h" + +struct MBR { + uint8_t code [440]; + uint32_t uniqueID; + uint16_t Reserved; + PartitionTableEntry TableEntries[4]; + uint16_t ValidBootsector; +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/PartitionTable/MBR/PartitionTableEntry.h b/source/kernel/PartitionTable/MBR/PartitionTableEntry.h new file mode 100644 index 0000000..e1bd4d6 --- /dev/null +++ b/source/kernel/PartitionTable/MBR/PartitionTableEntry.h @@ -0,0 +1,11 @@ +#pragma once +#include + +struct PartitionTableEntry{ + uint8_t driveAttribute; + uint8_t CHS_start_address [3]; + uint8_t PartitionType; + uint8_t CHS_lastSector_Address[3]; + uint32_t LBA_partition_start; + uint32_t Number_sectors_inPartition; +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/boot/boot.s b/source/kernel/boot/boot.s index cbfb2ce..18e50ca 100644 --- a/source/kernel/boot/boot.s +++ b/source/kernel/boot/boot.s @@ -36,7 +36,7 @@ _start: # Map address 0 movl $0, %esi 1: - cmpl $(_kernel_end - 0xC0000000), %esi + cmpl $(kernel_end - 0xC0000000), %esi jge 3f # Map physical address as "present and writable" diff --git a/source/kernel/bootcheck.h b/source/kernel/bootcheck.h new file mode 100644 index 0000000..e5f2ae8 --- /dev/null +++ b/source/kernel/bootcheck.h @@ -0,0 +1,91 @@ +#pragma once +#include "prekernel/multiboot.h" +#define CHECK_FLAG(flags, bit) ((flags) & (1 <<(bit))) + +#include "terminal/kterm.h" + + + +void CheckMBT ( multiboot_info_t* mbt ){ + /* Set MBI to the addresss of the multiboot information structure*/ + multiboot_info_t * mbi = (multiboot_info_t *) mbt; + +#ifdef __VERBOSE__ + /* Print out the flags */ + printf("flags = 0x%x\n", (unsigned) mbi->flags); +#endif + /* Are mem_* valid? */ + if ( CHECK_FLAG(mbi->flags,0)){ + // Do nothing + } + + /* is boot device valid ? */ + if (CHECK_FLAG (mbi->flags, 1)) + { +#ifdef __VERBOSE__ + printf("boot_device = 0x0%x\n", (unsigned) mbi->boot_device); +#endif + } + + /* is the command line passed? */ + if (CHECK_FLAG ( mbi->flags,2)) + { +#ifdef __VERBOSE__ + printf("cmdline = %s\n", (char *) mbi->cmdline); +#endif + } + + /* Are mods_* valid? */ + if(CHECK_FLAG ( mbi->flags, 3)){ + multiboot_module_t *mod; + uint32_t i; +#ifdef __VERBOSE__ + printf("mods count = %d, mods_addr = 0x%x\n", (int) mbi->mods_count, (int) mbi->mods_addr); + + for(i = 0, mod = (multiboot_module_t *) mbi->mods_addr; i < mbi->mods_count; i++ , mod++){ + printf(" mod start = 0x%x, mod_end = 0x%x, cmdline = %s\n", (unsigned) mod->mod_start, (unsigned) mod->mod_end, (char*) mod->cmdline); + } +#endif + } + + /* Bits 4 and 5 are mutually exclusive! */ + if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG(mbi->flags, 5)) + { +#ifdef __VERBOSE__ + printf("Both bits 4 and 5 are set.\n"); +#endif + return; + } + + /* Is the symbol table of a.out valid? */ + if (CHECK_FLAG(mbi->flags, 4)){ + multiboot_aout_symbol_table_t *multiboot_aout_sym = &(mbi->u.aout_sym); +#ifdef __VERBOSE__ + printf( "multiboot_aout_symbol_table: tabsize = 0x%0x, strsize = 0x%x, addr = 0x%x\n", + (unsigned) multiboot_aout_sym->tabsize, + (unsigned) multiboot_aout_sym->strsize, + (unsigned) multiboot_aout_sym->addr); +#endif + } + + /* Is the section header table of ELF valid? */ + if (CHECK_FLAG(mbi->flags, 5)){ + multiboot_elf_section_header_table_t *multiboot_elf_sec = &(mbi->u.elf_sec); +#ifdef __VERBOSE__ + printf("multiboot_elf_sec: num = %u, size = 0x%x, addr = 0x%x, shnd = 0x%x\n", + + (unsigned) multiboot_elf_sec->num, (unsigned) multiboot_elf_sec->size, + (unsigned) multiboot_elf_sec->addr, (unsigned) multiboot_elf_sec->shndx); +#endif + + } + + /* Draw diagonal blue line */ + if (CHECK_FLAG (mbt->flags, 12)){ +#ifdef __VERBOSE__ + printf("Can draw!\n"); +#endif + } + + +} \ No newline at end of file diff --git a/source/kernel/bootinfo.h b/source/kernel/bootinfo.h new file mode 100644 index 0000000..575a048 --- /dev/null +++ b/source/kernel/bootinfo.h @@ -0,0 +1,9 @@ +#pragma once +#include "memory/memoryinfo.h" + + +struct BootInfo{ + const char* BootStructureID = "BarinkOS"; + MemoryInfo* memory; + +}; \ No newline at end of file diff --git a/source/kernel/cpu.h b/source/kernel/cpu.h index 99cf6a8..bde0024 100644 --- a/source/kernel/cpu.h +++ b/source/kernel/cpu.h @@ -1,74 +1,16 @@ -#pragma once +#pragma once #include -/* -Based on Intel specifications. - -C++ interface for the cpu.s assembly file. - -©Nigel Barink - 2022 -*/ - -/* -* EFLAGS FUNCTIONS -*/ - uint32_t GetEFLAGS(); - -/* -* CONTROL_REGISTER_0 FUNCTIONS -*/ uint32_t GetCR0(); -/* - struct CR0_Register { - uint8_t PE :1; // Protection Mode Enabled 0 - uint8_t MP :1; // Monitor co-processor 1 - uint8_t EM :1; // Emulation 2 - uint8_t TS :1; // Task switched 3 - uint8_t ET :1; // Extension Type 4 - uint8_t NE :1; // Numeric error 5 - uint16_t Reserved :10; // 6,7,8,9,10,11,12,13,14,15 - uint8_t WP :1; // Write Protect 16 - uint8_t Reserved :1; // 17 - uint8_t AM :1; // Alligment Task 18 - uint16_t Reserved :10; // 19,20,21,22,23,24,25,26,27,28 - uint8_t NW :1; // Not-write through 29 - uint8_t CD :1; // Cache disable 30 - uint8_t PG :1; // Paging 31 - };*/ - - - -#define GET_PE_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x1) -#define GET_MP_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x2) -#define GET_EM_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x3) -#define GET_TS_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x4) -#define GET_ET_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x5) -#define GET_NE_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x6) - - -#define GET_PG_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0>>31) - -/* -* CONTROL_REGISTER_4 FUNCTIONS -*/ - -uint32_t GetCR4(); - -#define GET_PSE_BIT(CONTROL_REGISTER_4) (CONTROL_REGISTER_4&0x4) -#define GET_PAE_BIT(CONTROL_REGISTER_4) (CONTROL_REGISTER_4&0x5) - -/* -* CONTROL_REGISTER_2 FUNCTIONS -*/ uint32_t GetCR2(); -/* -* CONTROL_REGISTER_3 FUNCTIONS -*/ -uint32_t GetCR3(); \ No newline at end of file +uint32_t GetCR3(); + + +uint32_t GetCR4(); \ No newline at end of file diff --git a/source/kernel/drivers/acpi/rsdp.cpp b/source/kernel/drivers/acpi/rsdp.cpp new file mode 100644 index 0000000..5f4991f --- /dev/null +++ b/source/kernel/drivers/acpi/rsdp.cpp @@ -0,0 +1,46 @@ +#include "rsdp.h" + +void printRSD(RSDPTR* rsd){ + printf("Signature: "); + for(int i = 0; i < 8; i++){ + kterm_put(rsd->signature[i]); + } + kterm_put('\n'); + + printf("OEMID: "); + for(int i =0; i < 6 ; i++){ + kterm_put (rsd->OEMID[i]); + } + kterm_put('\n'); + + printf("Revision: %d\n", rsd->Revision); + printf("RSDT Address: 0x%x\n", rsd->RsdtAddress ); +} + +RSDPTR* FindRSD(){ + char* memory_byte = (char*) 0x000f2e14; + const void* string = "RSD PTR "; + + for( ; (uint32_t) memory_byte < 0x0100000; memory_byte+=10){ + if( memcmp(memory_byte , string , 8 ) == 0 ) { + printf("RSD PTR found at 0x%x !\n", memory_byte); + break; + } + } + + printRSD((RSDPTR*) memory_byte); + return (RSDPTR*) memory_byte; +} + + +RSDT* getRSDT(RSDPTR* rsd){ + + RSDT* rsdt = (RSDT*) rsd->RsdtAddress; + + printf("OEMID: "); + for(int i = 0; i < 6; i++){ + kterm_put(rsdt->header.OEMID[i]); + } + kterm_put('\n'); + return rsdt; +} \ No newline at end of file diff --git a/source/kernel/drivers/acpi/rsdp.h b/source/kernel/drivers/acpi/rsdp.h new file mode 100644 index 0000000..925b50d --- /dev/null +++ b/source/kernel/drivers/acpi/rsdp.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include "./../../terminal/kterm.h" +#include "../../../lib/include/mem.h" +struct RSDPTR { + char signature[8]; + uint8_t Checksum ; + char OEMID [6]; + uint8_t Revision; + uint32_t RsdtAddress; +}__attribute__((packed)); + +struct ACPISDTHeader{ + char Signature[4]; + uint32_t Length; + uint8_t CheckSum; + char OEMID[6]; + char OEMTableID[8]; + uint32_t OEMRevision; + uint32_t CreatorID; + uint32_t CreatorRevision; +}__attribute__((packed)); + + +struct RSDT{ + struct ACPISDTHeader header; + uint32_t PointerToSDT[]; // Length of array : (header.Length - sizeof(header))/ 4 +}__attribute__((packed)); + + +//NOTE: only scans EBDA enough to find RSD PTR in QEMU +RSDPTR* FindRSD(); + +void printRSD(RSDPTR* rsd); + +RSDT* getRSDT(RSDPTR* rsd); \ No newline at end of file diff --git a/source/kernel/drivers/ata/ataDevice.cpp b/source/kernel/drivers/ata/ataDevice.cpp new file mode 100644 index 0000000..05947f1 --- /dev/null +++ b/source/kernel/drivers/ata/ataDevice.cpp @@ -0,0 +1,194 @@ +#include "ataDevice.h" +#define IS_BIT_SET(x, bit) ((x >> bit & 0x1) == 1) + +void ATA_DEVICE::Soft_Reset(uint8_t DEVICE_CHANNEL,DEVICE_DRIVE drive){ + printf("Soft reseting drive...\n"); + outb(channels[DEVICE_CHANNEL].base + 7 , 0x4); + // wait a bit.. + for(int i = 0 ; i < 1000000; i++){ + asm volatile("NOP"); + } + outb(channels[DEVICE_CHANNEL].base + 7 , 0x0); + +} + + +void ATA_DEVICE::Identify(uint16_t DEVICE_CHANNEL,DEVICE_DRIVE drive ){ + // lets ignore which port we actually want to check for now ! + + /* + THE STEPS INVOLVED + + 1. Select the target drive by sending master (0x0A) or slave (0x0B) to the + drive select IO port + + 2. Set the Sectorcount, LBAlo, LBAmid and LBAhi IO ports to 0 + + 3. Send the identify command (0xEC) to the command IO port + + 4. Read the status port + 4.2 If the value is 0x0 the drive does not exist + 4.3 If it has any other value continue + 5. poll the status port until bit 7 is clear. + 6. Check if the LBAmid and LBAhi ports are non-zero + 6.2. If non-zero stop polling this is not an ATA device + 6.3 If zero continue + + 7. poll status port until bit 3 is set or bit 0 is set + + 8. if err is clear, read the data from the data port + + + */ + + + //printf("channel selected: 0x%x", DEVICE_CHANNEL); + // Assuming Master here + // Select the target drive + outb(DEVICE_CHANNEL | 6, drive); // on the primary bus select the master drive + outb(DEVICE_CHANNEL | 6 , 0x0); // write 0 to the controlport for some reason + + outb(DEVICE_CHANNEL | 6, drive); + uint8_t status = inb(DEVICE_CHANNEL | 7 ); + if(status == 0x00){ + printf("No drive\n"); + return; + } + // send the identify command; + outb(DEVICE_CHANNEL | 7, 0xEC); + + + // set the sectorCount, LBAlo, LBAmid, LBA,hi IO ports to 0 + outb(DEVICE_CHANNEL | 2, 0); + + outb(DEVICE_CHANNEL | 3, 0); + + outb(DEVICE_CHANNEL | 4, 0); + + outb(DEVICE_CHANNEL | 5, 0); + + // send the identify command ; + //printf("command sent!\n"); + outb(DEVICE_CHANNEL | 7 , 0xEC); + + // read the status port + uint8_t status2 = inb(DEVICE_CHANNEL | 7); + if( status2 == 0x00){ + printf("No drive\n"); + return; + } + + //printf("Waiting until ready...\n"); + while(((status2 & 0x80 == 0x80) + && (status2 & 0x01) != 0x01) + ) status2 = inb(DEVICE_CHANNEL | 7); + + if( status2 & 0x01){ + printf("Error!\n"); + return ; + } + + uint16_t deviceIdentify [256] = {0}; + + for ( int i = 0; i < 256; i++){ + uint16_t data; + asm volatile ("inw %1, %0" : "=a"(data): "Nd"(DEVICE_CHANNEL)); + + deviceIdentify[i] = data; + } + + + printf("Model-label (ASCII hex): "); + for(int i = 27; i < 47; i++){ + kterm_put((char)(deviceIdentify[i] >> 8)); + kterm_put((char)(deviceIdentify[i] & 0x00FF)); + } + kterm_put('\n'); + +} + +void ATA_DEVICE::Read(uint16_t DEVICE_CHANNEL, DEVICE_DRIVE drive, uint32_t LBA, uint16_t* buffer) { + /* + Assume you have a sectorcount byte and a 28 bit LBA value. A sectorcount of 0 means 256 sectors = 128K. + + Notes: - When you send a command byte and the RDY bit of the Status Registers is clear, you may have to wait (technically up to 30 seconds) for the drive to spin up, before DRQ sets. You may also need to ignore ERR and DF the first four times that you read the Status, if you are polling. + - for polling PIO drivers: After transferring the last uint16_t of a PIO data block to the data IO port, give the drive a 400ns delay to reset its DRQ bit (and possibly set BSY again, while emptying/filling its buffer to/from the drive). + - on the "magic bits" sent to port 0x1f6: Bit 6 (value = 0x40) is the LBA bit. This must be set for either LBA28 or LBA48 transfers. It must be clear for CHS transfers. Bits 7 and 5 are obsolete for current ATA drives, but must be set for backwards compatibility with very old (ATA1) drives. + + An example of a 28 bit LBA PIO mode read on the Primary bus: + + */ + + const int sectorCount = 1; + + // Floating bus check + uint8_t floatingBus = inb(DEVICE_CHANNEL | 7); + if (floatingBus == 0xFF){ + printf("Floating bus!!"); + return ; + } + + printf("Read LBA: 0x%x\n", LBA); + // Send 0xE0 for the "master" or 0xF0 for the "slave", ORed with the highest 4 bits of the LBA to port 0x1F6: outb(0x1F6, 0xE0 | (slavebit << 4) | ((LBA >> 24) & 0x0F)) + outb(DEVICE_CHANNEL | 6 , ( 0xE0 | (LBA >>28) ) ); + // Send a NULL byte to port 0x1F1, if you like (it is ignored and wastes lots of CPU time): outb(0x1F1, 0x00) + outb(DEVICE_CHANNEL | 1, 0x0000 ); + //Send the sectorcount to port 0x1F2: outb(0x1F2, (unsigned char) count) + outb(DEVICE_CHANNEL | 2, sectorCount); + //Send the low 8 bits of the LBA to port 0x1F3: outb(0x1F3, (unsigned char) LBA)) + outb(DEVICE_CHANNEL | 3, LBA); + //Send the next 8 bits of the LBA to port 0x1F4: outb(0x1F4, (unsigned char)(LBA >> 8)) + outb(DEVICE_CHANNEL | 4, (LBA >> 8)); + //Send the next 8 bits of the LBA to port 0x1F5: outb(0x1F5, (unsigned char)(LBA >> 16)) + outb(DEVICE_CHANNEL | 5, (LBA >> 16)); + //Send the "READ SECTORS" command (0x20) to port 0x1F7: outb(0x1F7, 0x20) + outb(DEVICE_CHANNEL | 7, 0x20); + + volatile int i,j; + for(i=0;i<2000;i++) + for(j=0;j<25000;j++) + asm("NOP"); + + //Wait for an IRQ or poll. + uint8_t status = inb(DEVICE_CHANNEL | 7); + if( status == 0x00){ + printf("No drive\n"); + return; + } + + printf("Status: %x\n", status); + // Check if busy! + while((status & 0x80) == 0x80){ + printf("Reading....\r"); + status = inb(DEVICE_CHANNEL | 7); + } + + + if ((status & 0x01) == 0x01){ + printf("Error occured during read!\n"); + return; + } + + //Transfer 256 16-bit values, a uint16_t at a time, into your buffer from I/O port 0x1F0. + if( status & 0x01){ + printf("Error!\n"); + printf("Status: 0x%x\n", status); + uint16_t error_register = inb(DEVICE_CHANNEL | 1); + printf("Error register 0x%x\n",error_register ); + return ; + } + for ( int i = 0; i < 256; i++){ + uint16_t data; + asm volatile ("inw %1, %0" : "=a"(data): "Nd"(DEVICE_CHANNEL)); + // printf (" %x ", data); + + buffer[i] = data; + } + + //Then loop back to waiting for the next IRQ (or poll again -- see next note) for each successive sector. + +} + +void ATA_DEVICE::Write(uint16_t DEVICE_CHANNEL, DEVICE_DRIVE drive) { + printf("Not implemented\n"); +} \ No newline at end of file diff --git a/source/kernel/drivers/ata/ataDevice.h b/source/kernel/drivers/ata/ataDevice.h new file mode 100644 index 0000000..730de3c --- /dev/null +++ b/source/kernel/drivers/ata/ataDevice.h @@ -0,0 +1,31 @@ +#pragma once +#include +#include "../io/io.h" +#include "../ide/ideCommands.h" +#include "../ide/sampleIDE.definitions.h" + +#include "../../terminal/kterm.h" + +/* +* This first driver wil make use of IO ports. +* Doing so means reading or writing from disk is going +* to be very cpu intensive. +* +*/ + +enum DEVICE_DRIVE{ + MASTER = 0xA0, + SLAVE = 0xB0 +}; + + + + +namespace ATA_DEVICE{ + void Identify(uint16_t, DEVICE_DRIVE); + void Read (uint16_t, DEVICE_DRIVE, uint32_t, uint16_t*); + void Write(uint16_t, DEVICE_DRIVE); + void Soft_Reset(uint8_t ,DEVICE_DRIVE ); +}; + + diff --git a/source/kernel/drivers/atapi/atapiDevice.cpp b/source/kernel/drivers/atapi/atapiDevice.cpp new file mode 100644 index 0000000..e619680 --- /dev/null +++ b/source/kernel/drivers/atapi/atapiDevice.cpp @@ -0,0 +1,145 @@ +#include "atapiDevice.h" +#define IS_BIT_SET(x, bit) ((x >> bit & 0x1) == 1) + +bool isPacketDevice(){ + + uint8_t LBAmid = inb(0x174); + uint8_t LBAhi = inb(0x175); + + printf(" LBAmid: 0x%x, LBAhi: 0x%x"); + return LBAmid == 0x14 && LBAhi == 0xEB; + +} + + +void ATAPI_DEVICE::Identify(uint8_t DEVICE_CHANNEL,DEVICE_DRIVE drive ){ + // lets ignore which port we actually want to check for now ! + + /* THE STEPS INVOLVED + + 1. Select the target drive by sending master (0x0A) or slave (0x0B) to the + drive select IO port + + 2. Set the Sectorcount, LBAlo, LBAmid and LBAhi IO ports to 0 + + 3. Send the identify command (0xEC) to the command IO port + + 4. Read the status port + 4.2 If the value is 0x0 the drive does not exist + 4.3 If it has any other value continue + 5. poll the status port until bit 7 is clear. + 6. Check if the LBAmid and LBAhi ports are non-zero + 6.2. If non-zero stop polling this is not an ATA device + 6.3 If zero continue + + 7. poll status port until bit 3 is set or bit 0 is set + + 8. if err is clear, read the data from the data port + + + */ + + // Select the target drive + outb(0x176, 0xA0); // on the secondary bus select the master drive + outb(0x170 + 0x206 , 0x0); // write 0 to the controlport for some reason + + outb(0x176, 0xA0); + // read the status port + uint8_t status = inb(0x177); + printf("status after drive select: 0x%x\n",status); + if( status == 0x00){ + printf("No drive\n"); + return; + } + + outb(0x176, 0xA0); + + + // Set the Sectorcount, LBAlo, LBAmid and LBAhi IO ports to 0 + outb(0x172, 0); + + outb(0x173, 0); + + outb(0x174, 0); + + outb(0x175, 0); + + // send the identify command; + printf("command sent!\n"); + outb(0x177, 0xA1); + + // read the status port + uint8_t status2 = inb(0x177); + if( status2 == 0x00){ + printf("No drive\n"); + return; + } + + + printf("Waiting until ready...\n"); + + while(((status2 & 0x80 == 0x80) + && (status2 & 0x01) != 0x01) + ) status2 = inb(0x177); + + + if(status2 & 0x01){ + printf("Error!"); + return; + } + + + // READ DATA + + uint16_t deviceIdentify [256] ={0}; + + for (int i= 0; i < 256; i++){ + uint16_t data; + asm volatile ( "in %1, %0" + : "=a"(data) + : "Nd"(0x170) ); + + + deviceIdentify[i] = data ; + + + } + + printf("Model-label (ASCII hex):\n"); + for(int i = 27; i < 47; i++){ + printf(" %x ",deviceIdentify[i]); + } + + printf("\nSerial number (ASCII hex):\n"); + for (int i = 10; i < 19; i++){ + printf(" %x ", deviceIdentify[i]); + } + + printf("\nFirmware revision (ASCII hex):\n"); + for (int i = 23; i < 26; i++){ + printf(" %x ", deviceIdentify[i]); + } + + printf("\nConfiguration: %x\n", deviceIdentify[0]); + + + + printf("\nData received!\n"); + + + + + + +} + + +void ATAPI_DEVICE::Read(uint8_t DEVICE_CHANNEL, DEVICE_DRIVE drive) { + printf("Not implemented"); +} + +void ATAPI_DEVICE::Write(uint8_t DEVICE_CHANNEL, DEVICE_DRIVE drive) { + printf("Not implemented"); +} + + diff --git a/source/kernel/drivers/atapi/atapiDevice.h b/source/kernel/drivers/atapi/atapiDevice.h new file mode 100644 index 0000000..ba480b9 --- /dev/null +++ b/source/kernel/drivers/atapi/atapiDevice.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include "../io/io.h" +#include "../ide/ideCommands.h" +#include "../ide/sampleIDE.definitions.h" + +#include "../../terminal/kterm.h" + +/* +* This first driver wil make use of IO ports. +* Doing so means reading or writing from disk is going +* to be very cpu intensive. +* +*/ + +enum DEVICE_DRIVE{ + MASTER = 0xA0, + SLAVE = 0xB0 +}; + + +namespace ATAPI_DEVICE +{ + bool isPacketDevice(); + void Identify ( uint8_t, DEVICE_DRIVE ); + void Read ( uint8_t, DEVICE_DRIVE ); + void Write ( uint8_t, DEVICE_DRIVE ); + +}; diff --git a/source/kernel/drivers/ide/ide.h b/source/kernel/drivers/ide/ide.h new file mode 100644 index 0000000..e7195de --- /dev/null +++ b/source/kernel/drivers/ide/ide.h @@ -0,0 +1,98 @@ +#pragma once +#include +#include "../pci/pciDevice.h" +#include "../pci/pci.h" +#include "../../terminal/kterm.h" +#include "ideCommands.h" +#include "sampleIDE.h" + +#define IS_BIT_SET(x, bit) ((x >> bit & 0x1) == 1) + +IDEChannelRegisters channels[2]; +IDE_DEVICE ide_devices[4]; + +inline void CheckProgIF(uint8_t ProgIF){ + if( IS_BIT_SET(ProgIF, 0) ) // Is the 0th bit set + { + printf ("Primary Channel is in PCI native mode\n"); + } else{ + printf("Primary Channel is in Compatibility mode\n"); + } + + if( IS_BIT_SET(ProgIF, 1)){ + printf("Bit 0 can be modified\n"); + }else{ + printf("Bit 0 cannot be modified\n"); + } + + if( IS_BIT_SET(ProgIF, 2)){ + printf("Secondary channel is in PCI native mode\n"); + }else{ + printf("Secondary channel is in Compatibility mode\n"); + } + + if( IS_BIT_SET(ProgIF, 3)){ + printf("Bit 2 can be modified\n"); + }else{ + printf("Bit 2 cannot be modified\n"); + } + + + if( IS_BIT_SET(ProgIF , 7)){ + printf("This is a bus master IDE Controller\n"); + } else{ + printf("This controller doesn't support DMA!\n"); + } + +} + +inline void TestIDEController(){ + // Do stuff + printf("Testing IDE controllers\n"); + + // NOTE: Testing done with a hard coded known PCI addres + // Of an intel PIIX3 IDE Controller + int bus = 0; + int device =1 , function = 1; + PCIBusAddress IDEControllerPCIAddress = PCIBusAddress{bus,device, function}; + + uint8_t ProgIF = GetProgIF(IDEControllerPCIAddress); + printf( "ProgIF: 0x%x\n" ,ProgIF); + + //CheckProgIF(ProgIF); + + // For this test will just assume all bits are set + // the CheckProgIF can check but on the test machine all bits are set anyways + + uint32_t BAR0,BAR1,BAR2,BAR3, BAR4; + + BAR0 = ReadBAR(IDEControllerPCIAddress, 0); + + BAR1 = ReadBAR(IDEControllerPCIAddress, 1); + + BAR2 = ReadBAR(IDEControllerPCIAddress, 2); + + BAR3 = ReadBAR(IDEControllerPCIAddress, 3); + + BAR4 = ReadBAR(IDEControllerPCIAddress, 4); + + // All bars are return 0xffffff for some as of yet mysterious reason! + printf( "BAR 0: 0x%x\n", BAR0); + + printf( "BAR 1: 0x%x\n", BAR1); + + printf( "BAR 2: 0x%x\n", BAR2); + + printf( "BAR 3: 0x%x\n", BAR3); + + printf( "BAR 4: 0x%x\n", BAR4); + + init_IDE(BAR0, BAR1, BAR2, BAR3, BAR4); + + // Read Something from disc + unsigned int maxByteCount = 20 ; + void* MDA_buffer = (void*)0xC0000000; + + + +} diff --git a/source/kernel/drivers/ide/ideCommands.h b/source/kernel/drivers/ide/ideCommands.h new file mode 100644 index 0000000..584756e --- /dev/null +++ b/source/kernel/drivers/ide/ideCommands.h @@ -0,0 +1,86 @@ +#pragma once + +// Commands +#define ATA_CMD_READ_PIO 0x20 +#define ATA_CMD_READ_PIO_EXT 0x24 +#define ATA_CMD_READ_DMA 0xC8 +#define ATA_CMD_READ_DMA_EXT 0x25 +#define ATA_CMD_WRITE_PIO 0x30 +#define ATA_CMD_WRITE_PIO_EXT 0x34 +#define ATA_CMD_WRITE_DMA 0xCA +#define ATA_CMD_WRITE_DMA_EXT 0x35 +#define ATA_CMD_CACHE_FLUSH 0xE7 +#define ATA_CMD_CACHE_FLUSH_EXT 0xEA +#define ATA_CMD_PACKET 0xA0 +#define ATA_CMD_IDENTIFY_PACKET 0xA1 +#define ATA_CMD_IDENTIFY 0xEC + +#define ATAPI_CMD_READ 0xA8 +#define ATAPI_CMD_EJECT 0x1B + +#define ATA_IDENT_DEVICETYPE 0 +#define ATA_IDENT_CYLINDERS 2 +#define ATA_IDENT_HEADS 6 +#define ATA_IDENT_SECTORS 12 +#define ATA_IDENT_SERIAL 20 +#define ATA_IDENT_MODEL 54 +#define ATA_IDENT_CAPABILITIES 98 +#define ATA_IDENT_FIELDVALID 106 +#define ATA_IDENT_MAX_LBA 120 +#define ATA_IDENT_COMMANDSETS 164 +#define ATA_IDENT_MAX_LBA_EXT 200 + +#define IDE_ATA 0x00 +#define IDE_ATAPI 0x01 + +#define ATA_MASTER 0x00 +#define ATA_SLAVE 0x01 + + +#define ATA_REG_DATA 0x00 +#define ATA_REG_ERROR 0x01 +#define ATA_REG_FEATURES 0x01 +#define ATA_REG_SECCOUNT0 0x02 +#define ATA_REG_LBA0 0x03 +#define ATA_REG_LBA1 0x04 +#define ATA_REG_LBA2 0x05 +#define ATA_REG_HDDEVSEL 0x06 +#define ATA_REG_COMMAND 0x07 +#define ATA_REG_STATUS 0x07 +#define ATA_REG_SECCOUNT1 0x08 +#define ATA_REG_LBA3 0x09 +#define ATA_REG_LBA4 0x0A +#define ATA_REG_LBA5 0x0B +#define ATA_REG_CONTROL 0x0C +#define ATA_REG_ALTSTATUS 0x0C +#define ATA_REG_DEVADDRESS 0x0D + +// Channels: +#define ATA_PRIMARY 0x00 +#define ATA_SECONDARY 0x01 + +// Directions: +#define ATA_READ 0x00 +#define ATA_WRITE 0x01 + + +// Status +#define ATA_SR_BSY 0x80 // Busy +#define ATA_SR_DRDY 0x40 // Drive ready +#define ATA_SR_DF 0x20 // Drive write fault +#define ATA_SR_DSC 0x10 // Drive seek complete +#define ATA_SR_DRQ 0x08 // Data request ready +#define ATA_SR_CORR 0x04 // Corrected data +#define ATA_SR_IDX 0x02 // Index +#define ATA_SR_ERR 0x01 // Error + + +// Errors +#define ATA_ER_BBK 0x80 // Bad block +#define ATA_ER_UNC 0x40 // Uncorrectable data +#define ATA_ER_MC 0x20 // Media changed +#define ATA_ER_IDNF 0x10 // ID mark not found +#define ATA_ER_MCR 0x08 // Media change request +#define ATA_ER_ABRT 0x04 // Command aborted +#define ATA_ER_TK0NF 0x02 // Track 0 not found +#define ATA_ER_AMNF 0x01 // No address mark \ No newline at end of file diff --git a/source/kernel/drivers/ide/sampleIDE.definitions.h b/source/kernel/drivers/ide/sampleIDE.definitions.h new file mode 100644 index 0000000..957dc60 --- /dev/null +++ b/source/kernel/drivers/ide/sampleIDE.definitions.h @@ -0,0 +1,29 @@ +#pragma once + +struct IDEChannelRegisters{ + unsigned short base; // I/O Base. + unsigned short ctrl; // Control Base + unsigned short bmide; // Bus Master IDE + unsigned char nIEN; // IEN (no interrupt) +}; + + +struct IDE_DEVICE { + unsigned char Reserved; // 0 (Empty) or 1 (This device exists). + unsigned char Channel; // 0 (Primary Channel) or 1 (Secondary Channel). + unsigned char Drive; // 0 (Master Drive) or 1 (Slave Drive). + unsigned short Type; // 0 ATA, 1:ATAPI + unsigned short Signature; // Drive Signature + unsigned short Capabilities; // Features. + unsigned int CommandSets; // Command Sets Supported. + unsigned int Size; // Size in Sectors (NOTE: Seems unused nowadays as i've only seen the value be zero + unsigned char Model[41]; // Model in string. +} ; + + + +extern IDEChannelRegisters channels[2]; +extern IDE_DEVICE ide_devices[4]; +extern unsigned char ide_buf[2048]; +extern unsigned char ide_irq_invoked; +extern unsigned char atapi_packet[12]; diff --git a/source/kernel/drivers/ide/sampleIDE.h b/source/kernel/drivers/ide/sampleIDE.h new file mode 100644 index 0000000..3976ac3 --- /dev/null +++ b/source/kernel/drivers/ide/sampleIDE.h @@ -0,0 +1,242 @@ +#pragma once +#include +#include "../../terminal/kterm.h" +#include "sampleIDE.definitions.h" +#include "ideCommands.h" + +void Detect_IO_Ports(uint32_t BAR0, uint32_t BAR1,uint32_t BAR2, uint32_t BAR3, uint32_t BAR4); +void DetectDevices(); + +unsigned char ide_buf[2048] = {0}; +unsigned char ide_irq_invoked = 0; +unsigned char atapi_packet[12] = {0xA8,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +void wait(int t){ + volatile int i,j; + for(i=0;i 0x07 && reg < 0x0C) + ide_write(channel, ATA_REG_CONTROL, 0x80 | channels[channel].nIEN); + if (reg < 0x08) + outb(channels[channel].base + reg - 0x00, data); + else if (reg < 0x0C) + outb(channels[channel].base + reg - 0x06, data); + else if (reg < 0x0E) + outb(channels[channel].ctrl + reg - 0x0A, data); + else if (reg < 0x16) + outb(channels[channel].bmide + reg - 0x0E, data); + if (reg > 0x07 && reg < 0x0C) + ide_write(channel, ATA_REG_CONTROL, channels[channel].nIEN); +} + +unsigned char ide_read(unsigned char channel, unsigned char reg){ + unsigned char result; + if( reg > 0x07 && reg < 0x0C) + ide_write(channel,ATA_REG_CONTROL, 0x80 | channels[channel].nIEN); + if( reg < 0x08) + result = inb(channels[channel].base + reg - 0x00); + else if (reg < 0x0C) + result = inb(channels[channel].base + reg - 0x06); + else if (reg < 0x0E) + result = inb(channels[channel].ctrl + reg - 0x0A); + else if (reg < 0x16) + result = inb(channels[channel].bmide + reg - 0x0E); + if (reg > 0x07 && reg < 0x0C) + ide_write(channel, ATA_REG_CONTROL, channels[channel].nIEN); + return result; +} + +void ide_read_buffer(unsigned char channel, unsigned char reg, unsigned int buffer, unsigned int quads){ + if (reg > 0x07 && reg < 0x0C) + ide_write(channel, ATA_REG_CONTROL, 0x80 | channels[channel].nIEN); + if (reg < 0x08) + insl(channels[channel].base + reg - 0x00, (void *)buffer, quads); + else if (reg < 0x0C) + insl(channels[channel].base + reg - 0x06, (void *)buffer, quads); + else if (reg < 0x0E) + insl(channels[channel].ctrl + reg - 0x0A, (void *)buffer, quads); + else if (reg < 0x16) + insl(channels[channel].bmide + reg - 0x0E, (void *)buffer, quads); + if (reg > 0x07 && reg < 0x0C) + ide_write(channel, ATA_REG_CONTROL, channels[channel].nIEN); +} + +unsigned char ide_polling(unsigned char channel, unsigned int advanced_check) { + + // (I) Delay 400 nanosecond for BSY to be set: + // ------------------------------------------------- + for(int i = 0; i < 4; i++) + ide_read(channel, ATA_REG_ALTSTATUS); // Reading the Alternate Status port wastes 100ns; loop four times. + + // (II) Wait for BSY to be cleared: + // ------------------------------------------------- + while (ide_read(channel, ATA_REG_STATUS) & ATA_SR_BSY) + ; // Wait for BSY to be zero. + + if (advanced_check) { + unsigned char state = ide_read(channel, ATA_REG_STATUS); // Read Status Register. + + // (III) Check For Errors: + // ------------------------------------------------- + if (state & ATA_SR_ERR) + return 2; // Error. + + // (IV) Check If Device fault: + // ------------------------------------------------- + if (state & ATA_SR_DF) + return 1; // Device Fault. + + // (V) Check DRQ: + // ------------------------------------------------- + // BSY = 0; DF = 0; ERR = 0 so we should check for DRQ now. + if ((state & ATA_SR_DRQ) == 0) + return 3; // DRQ should be set + + } + + return 0; // No Error. + +} + +unsigned char ide_print_error(unsigned int drive, unsigned char err) { + if (err == 0) + return err; + + printf("IDE:"); + if (err == 1) {printf("- Device Fault\n "); err = 19;} + else if (err == 2) { + unsigned char st = ide_read(ide_devices[drive].Channel, ATA_REG_ERROR); + if (st & ATA_ER_AMNF) {printf("- No Address Mark Found\n "); err = 7;} + if (st & ATA_ER_TK0NF) {printf("- No Media or Media Error\n "); err = 3;} + if (st & ATA_ER_ABRT) {printf("- Command Aborted\n "); err = 20;} + if (st & ATA_ER_MCR) {printf("- No Media or Media Error\n "); err = 3;} + if (st & ATA_ER_IDNF) {printf("- ID mark not Found\n "); err = 21;} + if (st & ATA_ER_MC) {printf("- No Media or Media Error\n "); err = 3;} + if (st & ATA_ER_UNC) {printf("- Uncorrectable Data Error\n "); err = 22;} + if (st & ATA_ER_BBK) {printf("- Bad Sectors\n "); err = 13;} + } else if (err == 3) {printf("- Reads Nothing\n "); err = 23;} + else if (err == 4) {printf("- Write Protected\n "); err = 8;} + printf("- [%s %s] %s\n", + (const char *[]){"Primary", "Secondary"}[ide_devices[drive].Channel], // Use the channel as an index into the array + (const char *[]){"Master", "Slave"}[ide_devices[drive].Drive], // Same as above, using the drive + ide_devices[drive].Model); + + return err; +} + + +inline void init_IDE( uint32_t BAR0, uint32_t BAR1,uint32_t BAR2, uint32_t BAR3, uint32_t BAR4) +{ + Detect_IO_Ports( BAR0, BAR1, BAR2, BAR3, BAR4); + + printf("ATA Primary port, base: 0x%x, ctrl: 0x%x\n", channels[ATA_PRIMARY].base , channels[ATA_PRIMARY].ctrl); + printf("ATA Secondary port, base: 0x%x, ctrl: 0x%x\n", channels[ATA_SECONDARY].base , channels[ATA_SECONDARY].ctrl); + + // 2- Disable IRQs: + ide_write(ATA_PRIMARY , ATA_REG_CONTROL, 2); + ide_write(ATA_SECONDARY, ATA_REG_CONTROL, 2); + + DetectDevices(); + + return; + // 4- Print Summary: + for (int i = 0; i < 4; i++) + if (ide_devices[i].Reserved == 1) { + printf(" Found %s Drive %d bytes - %x\n", + (const char *[]){"ATA", "ATAPI"}[ide_devices[i].Type], /* Type */ + ide_devices[i].Size / 2, /* Size */ + ide_devices[i].Model); + } +} + + +// 3- Detect ATA-ATAPI Devices: +void DetectDevices(){ + int i, j, k, count = 0; + + for (i = 0; i < 2; i++) + for (j = 0; j < 2; j++) { + + unsigned char err = 0, type = IDE_ATA, status; + ide_devices[count].Reserved = 0; // Assuming that no drive here. + + // (I) Select Drive: + ide_write(i, ATA_REG_HDDEVSEL, 0xA0 | (j << 4)); // Select Drive. + wait(1000); // Wait 1ms for drive select to work. + + // (II) Send ATA Identify Command: + ide_write(i, ATA_REG_COMMAND, ATA_CMD_IDENTIFY); + wait(1000); + + // (III) Polling: + if (ide_read(i, ATA_REG_STATUS) == 0) continue; // If Status = 0, No Device. + + while(1) { + status = ide_read(i, ATA_REG_STATUS); + if ((status & ATA_SR_ERR)) {err = 1; break;} // If Err, Device is not ATA. + if (!(status & ATA_SR_BSY) && (status & ATA_SR_DRQ)) break; // Everything is right. + } + + // (IV) Probe for ATAPI Devices: + if (err != 0) { + unsigned char cl = ide_read(i, ATA_REG_LBA1); + unsigned char ch = ide_read(i, ATA_REG_LBA2); + + if (cl == 0x14 && ch ==0xEB) + type = IDE_ATAPI; + else if (cl == 0x69 && ch == 0x96) + type = IDE_ATAPI; + else + continue; // Unknown Type (may not be a device). + + ide_write(i, ATA_REG_COMMAND, ATA_CMD_IDENTIFY_PACKET); + wait(1000); + } + + // (V) Read Identification Space of the Device: + ide_read_buffer(i, ATA_REG_DATA, (unsigned int) ide_buf, 128); + + // (VI) Read Device Parameters: + ide_devices[count].Reserved = 1; + ide_devices[count].Type = type; + ide_devices[count].Channel = i; + ide_devices[count].Drive = j; + ide_devices[count].Signature = *((unsigned short *)(ide_buf + ATA_IDENT_DEVICETYPE)); + ide_devices[count].Capabilities = *((unsigned short *)(ide_buf + ATA_IDENT_CAPABILITIES)); + ide_devices[count].CommandSets = *((unsigned int *)(ide_buf + ATA_IDENT_COMMANDSETS)); + + // (VII) Get Size: + if (ide_devices[count].CommandSets & (1 << 26)) + // Device uses 48-Bit Addressing: + ide_devices[count].Size = *((unsigned int *)(ide_buf + ATA_IDENT_MAX_LBA_EXT)); + else + // Device uses CHS or 28-bit Addressing: + ide_devices[count].Size = *((unsigned int *)(ide_buf + ATA_IDENT_MAX_LBA)); + + // (VIII) String indicates model of device (like Western Digital HDD and SONY DVD-RW...): + for(k = 0; k < 40; k += 2) { + ide_devices[count].Model[k] = ide_buf[ATA_IDENT_MODEL + k + 1]; + ide_devices[count].Model[k + 1] = ide_buf[ATA_IDENT_MODEL + k];} + ide_devices[count].Model[40] = 0; // Terminate String. + + count++; + } +} + + +void Detect_IO_Ports(uint32_t BAR0, uint32_t BAR1,uint32_t BAR2, uint32_t BAR3, uint32_t BAR4){ + // 1 Detect I/O Ports which interface an IDE Controller + + // Based on the implementation within serenity + channels[ATA_PRIMARY].base = (BAR0 == 0x1 || BAR0 == 0x0) ? 0x1F0 : BAR0 & (~1); + channels[ATA_PRIMARY ].ctrl = (BAR1 == 0x1 || BAR1 == 0x0) ? 0x3F6 : BAR1 & (~1); + channels[ATA_SECONDARY].base = (BAR2 == 0x1 || BAR2 == 0x0) ? 0x170 : BAR2 & (~1); + channels[ATA_SECONDARY].ctrl = (BAR3 == 0x1 || BAR3 == 0x0) ? 0x376 : BAR3 & (~1); + channels[ATA_PRIMARY ].bmide = (BAR4 & (~1)) + 0; // Bus Master IDE + channels[ATA_SECONDARY].bmide = (BAR4 & (~1)) + 8; // Bus Master IDE + +} \ No newline at end of file diff --git a/source/kernel/io.cpp b/source/kernel/drivers/io/io.cpp similarity index 82% rename from source/kernel/io.cpp rename to source/kernel/drivers/io/io.cpp index e87fd90..e3e259b 100644 --- a/source/kernel/io.cpp +++ b/source/kernel/drivers/io/io.cpp @@ -12,9 +12,10 @@ unsigned short inw_p(unsigned short ){ // TODO: implement me! return 0; } -unsigned int inl(unsigned short ){ -// TODO: implement me! - return 0; +uint32_t inl( int port ){ + unsigned int data; + asm volatile ("inl %w1, %0": "=a" (data): "d" (port)); + return data; } unsigned int inl_p(unsigned short ){ // TODO: implement me! @@ -31,9 +32,12 @@ void outw(unsigned short , unsigned short ){ void outw_p(unsigned short , unsigned short ){ } -void outl(unsigned int , unsigned short ){ +void outl( int port , uint32_t data ){ + asm volatile ("outl %0, %1" :: "a" (data), "dn"(port)); } + + void outl_p(unsigned int , unsigned short ){ } diff --git a/source/kernel/io.h b/source/kernel/drivers/io/io.h similarity index 69% rename from source/kernel/io.h rename to source/kernel/drivers/io/io.h index c7fd561..094d595 100644 --- a/source/kernel/io.h +++ b/source/kernel/drivers/io/io.h @@ -12,21 +12,17 @@ static inline uint8_t inb(uint16_t port) unsigned char inb_p(unsigned short port); unsigned short inw(unsigned short port); unsigned short inw_p(unsigned short port); -unsigned int inl(unsigned short port); +uint32_t inl( int port ); unsigned int inl_p(unsigned short port); static inline void outb(uint16_t port, uint8_t val) { asm volatile ( "outb %0, %1" : : "a"(val), "Nd"(port) ); - /* There's an outb %al, $imm8 encoding, for compile-time constant port numbers that fit in 8b. (N constraint). - * Wider immediate constants would be truncated at assemble-time (e.g. "i" constraint). - * The outb %al, %dx encoding is the only option for all other cases. - * %1 expands to %dx because port is a uint16_t. %w1 could be used if we had the port number a wider C type */ } void outb_p(unsigned char value, unsigned short port); void outw(unsigned short value, unsigned short port); void outw_p(unsigned short value, unsigned short port); -void outl(unsigned int value, unsigned short port); +void outl( int port , uint32_t data ); void outl_p(unsigned int value, unsigned short port); void insb(unsigned short port, void *addr, diff --git a/source/kernel/drivers/pci/pci.cpp b/source/kernel/drivers/pci/pci.cpp index 3f81c29..c7ba0ac 100644 --- a/source/kernel/drivers/pci/pci.cpp +++ b/source/kernel/drivers/pci/pci.cpp @@ -1,108 +1,247 @@ #include "pci.h" -uint16_t ConfigReadWord (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset){ +#define PCI_BUS_ADDR_SHIFT 16 +#define PCI_DEVICE_ADDR_SHIFT 11 +#define PCI_FUNCTION_ADDR_SHIFT 8 +#define PCI_ENABLE_ADDR_SHIFT 31 + +const char* GetClassCodeName (uint64_t ClassCode ) { + + switch (ClassCode) + { + case 0x0 : + return "Unclassified"; + break; + + case 0x1: + return "Mass Storage Controller"; + break; + + case 0x2: + return "Network Controller"; + break; + + case 0x3: + return "Display Controller"; + break; + + case 0x4: + return "Multimedia Controller"; + break; + + case 0x5: + return "Memory Controller"; + break; + + case 0x6: + return "Bridge"; + break; + + case 0x7 : + return "Simple Communication Controller"; + break; + + case 0x8: + return "Base System Peripheral"; + break; + + case 0x9: + return "Input Device Controller"; + break; + + case 0xA: + return "Docking station"; + break; + case 0xB: + return "Processor"; + break; + + case 0xC: + return "Serial Bus Controller"; + break; + + case 0xD: + return "Wireless Controller"; + break; + + case 0xE: + return "Intelligent Controller"; + break; + + case 0xF: + return "Satellite Communication Controller"; + break; + + case 0x10: + return "Encryption Controller"; + break; + + case 0x11: + return "Signal Processing Controller"; + break; + + case 0x12: + return "Processing Accelerator"; + break; + + case 0x13: + return "Non-Essential Instrumentation"; + break; + + default: + return "Unknown"; + break; + } + +} + +const char* getVendor( uint32_t VendorID){ + switch (VendorID) + { + case 0x8086: + return "Intel Corporation"; + break; + + case 0x10DE: + return "NVIDIA Corporation"; + break; + + case 0x1022: + return "Advanced Micro Devices, Inc.[AMD]"; + break; + + case 0x1002: + return "Advanced Micor Devices, Inc.[AMD/ATI]"; + break; + + default: + return "Vendor Unkown"; + break; + } + +} + +uint32_t ConfigReadWord ( PCIBusAddress& PCIDeviceAddress , uint8_t offset){ + outl(CONFIG_ADDRESS , PCIDeviceAddress.getAddress() | offset ); + return inl(CONFIG_DATA); +} + +uint32_t ConfigReadWord (uint8_t bus, uint8_t device, uint8_t func, uint8_t offset){ uint32_t address; - uint32_t lbus = (uint32_t) bus; - uint32_t lslot = (uint32_t) slot; - uint32_t lfunc = (uint32_t) func; - uint16_t tmp = 0; - /* Create configuration address as per Figure 1 */ - address = (uint32_t) ((lbus << 16) | (lslot << 11) | (lfunc << 8) | (offset & 0xFC) |((uint32_t) 0x80000000) ); - /*write out the address */ + address = (uint32_t) ( + ((uint32_t) 1 << PCI_ENABLE_ADDR_SHIFT) | + ((uint32_t)bus << PCI_BUS_ADDR_SHIFT) | + ((uint32_t)device << PCI_DEVICE_ADDR_SHIFT) | + ((uint32_t)func << PCI_FUNCTION_ADDR_SHIFT) | + offset ); + outl(CONFIG_ADDRESS, address); - /* read in the data */ - /* (offset & 2 ) * 8 ) = o will choosse the first word of the 32 bits register*/ - tmp = (uint16_t)((inl(CONFIG_DATA)) >> ((offset & 2) * 8) & 0xFFFF); - return (tmp); + + + return inl(CONFIG_DATA); } -uint16_t CheckVendor (uint8_t bus, uint8_t slot) { - uint16_t vendor, device; - /* - Try and read the first configuration register. Since there ar no - vendors that == 0xFFFF, it must be a non-existent device. - */ - if((vendor = ConfigReadWord(bus, slot, 0,0)) != 0xFFFF) { - device = ConfigReadWord(bus, slot, 0,2); - // Possible read more config values ... - } return (vendor); +uint8_t GetHeaderType( PCIBusAddress& PCIDeviceAddress ){ + uint32_t header_information = ConfigReadWord(PCIDeviceAddress , 0xC); + return (uint8_t) ( + ((header_information >> 16) //Get higher half + & 0x00FF) // Select the last two bytes + & 0x7F ); // Mask bit 7 as it indicates if the device is a mulit function device! } -void checkDevice (uint8_t bus, uint8_t device ) { - uint8_t function = 0; +uint16_t GetClassCodes( PCIBusAddress& PCIDeviceAddress ){ + uint32_t classcodes = ConfigReadWord(PCIDeviceAddress, 0x8); + return (uint16_t)((uint32_t)classcodes >> 16); + +} - uint16_t vendorID = CheckVendor(bus, device); - if (vendorID == 0xFFFF) { - return; - } +bool IsMultiFunctionDevice(PCIBusAddress& PCIDeviceAddress){ + uint32_t header_information = ConfigReadWord(PCIDeviceAddress, 0xC); + return (((header_information>>16) + & 0x80) + >> 7 ); +} - checkFunction (bus, device, function ); - headerType = getHeaderType(bus, device, function ); - if( (headerType & 0x80) != 0) { - /* It is a multi-function device, so check remaining functions */ - for (function = 1; function < 8; function++){ - if (CheckVendor(bus, device)!= 0xFFFF){ - checkFunction(bus, device, function ); - } - } - } +void PrintPCIDeviceInfo (PCIBusAddress& PCIDeviceAddress) +{ + uint32_t DeviceID = (GetDevice(PCIDeviceAddress.bus, PCIDeviceAddress.device, PCIDeviceAddress.function) >> 16); + uint32_t VendorID = GetDevice(PCIDeviceAddress.bus, PCIDeviceAddress.device, PCIDeviceAddress.function) & 0xFFFF; + printf("Device found!\n"); + printf("Bus: %d, Device: %d, function: %d \n", PCIDeviceAddress.bus, PCIDeviceAddress.device, PCIDeviceAddress.function); + printf("DeviceID: 0x%x, Vendor: %s\n", + DeviceID + , getVendor(VendorID) ); + + + + + uint8_t header_type = GetHeaderType(PCIDeviceAddress); + printf( "Header type: 0x%x\n", header_type); + + uint16_t deviceClasses = GetClassCodes(PCIDeviceAddress); + printf("class: %s, subClass: %d\n\n", GetClassCodeName((deviceClasses >>8)), deviceClasses & 0xFF); } +void PCI_Enumerate(){ + int devicesFound = 0; + // loop through all possible busses, devices and their functions; + for( int bus = 0 ; bus < 256 ; bus++) + { + + for(int device = 0; device < 32 ; device ++) + { + + + int function = 0; -void checkFunction (uint8_t bus, uint8_t device, uint8_t function ){ - uint8_t baseClass; - uint8_t subClass; - uint8_t secondaryBus; + //uint64_t DeviceIdentify = ConfigReadWord(bus, device, function,0x0); + uint32_t DeviceID = GetDevice(bus, device, function) >> 16; - baseClass = getBaseClass(bus, device, function); - subClass = getSubClass (bus, device, function ); - if ( (baseClass == 0x06) && (subClass == 0x04)){ - secondaryBus = getSecondaryBus(bus,device, function); - checkBus(secondaryBus); - } -} + + + if( DeviceID != 0xFFFF){ + PCIBusAddress busAddress = + PCIBusAddress{bus, device, function }; + + PrintPCIDeviceInfo(busAddress); + + // iterate over the functions if it is a multi function device! + if( IsMultiFunctionDevice(busAddress) ){ + printf("Multi function device! \n"); + printf("Check remaining Functions\n"); + for ( function = 1 ; function < 8; function++) + { + uint32_t DeviceID = GetDevice(bus, device, function) >> 16; + + if( DeviceID != 0xFFFF){ + PCIBusAddress busAddress2 = PCIBusAddress{bus, device, function}; + PrintPCIDeviceInfo(busAddress2); + devicesFound++; + } + } + + } -// Brute-force scan -void checkAllBuses (){ - uint16_t bus; - uint8_t device; - for(bus = 0; bus < 256; bus++){ - for(device = 0; device < 32; device++){ - checkDevice(bus,device); - } - } -} -// Recursive scan -void checkBus (uint8_t bus){ - uint8_t device; - - for(device = 0; device < 32; device ++){ - checkDevice(bus,device); - } -} - -void checkAllBuses(){ - uint8_t function; - uint8_t bus; - - headerType = getHeaderType(0,0,0); - if ( (headerType & 0x80) == 0 ){ - /* Single PCI host controller */ - checkBus(0); - } else{ - /* Multiple PCI host controllers */ - for (function = 0; function < 8; function++){ - if( CheckVendor(0,0) != 0xFFFF) { - break; + devicesFound++; + } } - bus = function; - checkBus(bus); + } - } + printf("Found %d PCI devices!\n", devicesFound); +} + +uint8_t GetProgIF (PCIBusAddress& PCIDeviceAddress){ + uint32_t data = ConfigReadWord(PCIDeviceAddress, 0x8); + return ((data >> 8) & 0xFF); +} + +uint32_t ReadBAR ( PCIBusAddress& PCIDeviceAddress, int bar_number){ + int offsetToBar = 0x10 + (bar_number* 0x4); + return ConfigReadWord(PCIDeviceAddress, offsetToBar); } \ No newline at end of file diff --git a/source/kernel/drivers/pci/pci.h b/source/kernel/drivers/pci/pci.h index 93b15ce..272e0f4 100644 --- a/source/kernel/drivers/pci/pci.h +++ b/source/kernel/drivers/pci/pci.h @@ -1,58 +1,38 @@ #pragma once #include -#include "io.h" +#include "../io/io.h" +#include "../../terminal/kterm.h" +#include "pciDevice.h" + // Configuration Space Access Mechanism #1 #define CONFIG_ADDRESS 0xCF8 // Configuration adress that is to be accessed #define CONFIG_DATA 0xCFC // Will do the actual configuration operation -/* -CONFIG_ADDRESS - -32 bit register - -bit 31 Enable bit (Should CONFIG_DATA be translatedc to configuration cycles) -bit 30 - 24 Reserved -bit 23 - 16 Bus Number (Choose a specific PCI BUS) -bit 15 - 11 Device Number (Selects specific device one the pci bus) -bit 10 - 8 Function Number (Selects a specific function in a device) -bit 7 - 0 Register Offset (Offset in the configuration space of 256 Bytes ) NOTE: lowest two bits will always be zero - -*/ +extern const char* ClassCodeTable [0x13]; -/* -PCI Device structure -Register offset bits 31-24 bits 23-16 bits 15-8 bits 7-0 -00 00 Device ID <---- Vendor ID <------- -01 04 Status <---- Command <------- -02 08 Class code Sub class Prog IF Revision ID -03 0C BIST Header Type Ltncy Timer Cache line Size -04 10 Base address #0 (BAR0) -05 14 Base address #1 (BAR1) -06 18 Base address #2 (BAR2) -07 1C Base address #3 (BAR3) -08 20 Base address #4 (BAR4) -09 24 Base address #5 (BAR5) -0A 28 Cardbus CIS Pointer -0B 2C Subsystem ID <------ Subsystem Vendor ID <------- -0C 30 Expansion ROM base address -0D 34 Reserved <------- Capabilities Pointer <------ -0E 38 Reserved <------- <-------- <-------- -0F 3C Max ltncy Min Grant Interrupt PIN Interrupt Line +// Note: this could be used to make the api for receiving PCI class codes a bit +// nicer. +struct ClassCodes { + uint8_t ClassCode; + uint8_t DeviceClass; +}__attribute__((packed)); -*/ +uint32_t ConfigReadWord (uint8_t bus, uint8_t device, uint8_t func, uint8_t offset); +uint32_t ConfigReadWord ( PCIBusAddress& PCIDeviceAddress , uint8_t offset); + inline uint64_t GetDevice (int bus, int device, int function ){ + return ConfigReadWord(bus, device, function,0x0); + } -/* -The idea for now is to support the minimal things necessary to find ATA supported drives - */ +uint8_t GetHeaderType( PCIBusAddress& PCIDeviceAddress ); +uint16_t GetClassCodes( PCIBusAddress& PICDeviceAddress ); +const char* getVendor( uint64_t VendorID); +const char* GetClassCodeName (uint64_t ClassCode ); -// Lets write some boiler plate configuration code +uint8_t GetProgIF (PCIBusAddress& PCIDeviceAddress); +void PCI_Enumerate(); -uint16_t ConfigReadWord (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset); - -uint16_t CheckVendor (uint8_t bus, uint8_t slot); - -void checkDevice (uint8_t bus, uint8_t device ); \ No newline at end of file +uint32_t ReadBAR ( PCIBusAddress& PCIDeviceAddress, int bar_number); \ No newline at end of file diff --git a/source/kernel/drivers/pci/pciDevice.cpp b/source/kernel/drivers/pci/pciDevice.cpp new file mode 100644 index 0000000..e4507fb --- /dev/null +++ b/source/kernel/drivers/pci/pciDevice.cpp @@ -0,0 +1,7 @@ + #include "pciDevice.h" + +// NOTE: we would really like to return a pointer +// to the newly created PCIBusAddress struct; + PCIBusAddress const PCIDevice::PCIAddress(){ + return PCIBusAddress{bus ,device, function}; + } \ No newline at end of file diff --git a/source/kernel/drivers/pci/pciDevice.h b/source/kernel/drivers/pci/pciDevice.h new file mode 100644 index 0000000..9ef88f2 --- /dev/null +++ b/source/kernel/drivers/pci/pciDevice.h @@ -0,0 +1,54 @@ +#pragma once +#include +/* +* PCI devices API +*/ +struct PCIBusAddress{ + + int bus ; + int device ; + int function; + + + uint32_t getAddress( ){ + return ((uint32_t) 1 << 31) | + ((uint32_t) bus << 16) | + ((uint32_t) device << 11)| + ((uint32_t) function << 8) | + 0x0000; + + }; +}; + +class PCIDevice { + public : + PCIDevice (PCIBusAddress* , int ); + ~PCIDevice(); + PCIBusAddress const PCIAddress(); + + + inline const char* getDeviceString(){ + return "Not implemented"; //GetClassCodeName(deviceclass); + } + + inline const char* getVendorString(){ + return "Not implemented"; // getVendor(VendorID); + } + + inline void setVendorID (uint16_t id) { + this->VendorID = id; + } + + private: + int bus; + int device; + int function; + + uint16_t VendorID; + uint16_t DeviceID; + uint8_t deviceclass; + uint8_t devicesubclass; + + int headerType; + +}; diff --git a/source/kernel/drivers/pic/pic.h b/source/kernel/drivers/pic/pic.h index 64a8188..6788013 100644 --- a/source/kernel/drivers/pic/pic.h +++ b/source/kernel/drivers/pic/pic.h @@ -1,5 +1,5 @@ #pragma once -#include "../../io.h" +#include "../io/io.h" #define PIC1 0x20 /* IO base address for master PIC */ #define PIC2 0xA0 /* IO base address for slave PIC */ diff --git a/source/kernel/drivers/pit/pit.cpp b/source/kernel/drivers/pit/pit.cpp index 6b5eaa3..93d1b9e 100644 --- a/source/kernel/drivers/pit/pit.cpp +++ b/source/kernel/drivers/pit/pit.cpp @@ -1,5 +1,5 @@ #include "pit.h" - +#include "../../terminal/kterm.h" uint32_t pit_tick = 0; diff --git a/source/kernel/drivers/pit/pit.h b/source/kernel/drivers/pit/pit.h index 72bb383..ad9235d 100644 --- a/source/kernel/drivers/pit/pit.h +++ b/source/kernel/drivers/pit/pit.h @@ -1,7 +1,6 @@ #pragma once #include -#include "../../io.h" -#include "../../terminal/kterm.h" +#include "../io/io.h" #define PIT_DATA_0 0x40 #define PIT_DATA_1 0x41 #define PIT_DATA_2 0x42 diff --git a/source/kernel/filesystem/EXT2/SuperBlock.h b/source/kernel/filesystem/EXT2/SuperBlock.h new file mode 100644 index 0000000..35a5a94 --- /dev/null +++ b/source/kernel/filesystem/EXT2/SuperBlock.h @@ -0,0 +1,29 @@ +#pragma once +#include +struct SuperBlock { + uint32_t NumberOfInodes; + uint32_t NumberOfBlocks; + uint32_t NumberOfReservedBlocks; + uint32_t NumberOfUnallocatedBlocks; + uint32_t NumberOfUnallocatedInodes; + uint32_t BlockNumberOfSuperBlock; + uint32_t BlockSize;// Something about a shift left + uint32_t FragmentSize; + uint32_t NumberOfBlocksInGroup; + uint32_t NumberOfFragmentsInBlockGroup; + uint32_t NumberOfInodesInBlockGroup; + uint32_t LastMountTime; // POSIX + uint32_t LastWrittenTime; // POSIX + uint16_t TimesMountedSinceCheck; + uint16_t TimesMountedUntilCheck; + uint16_t EXT_SIG ; // 0xef53 + uint16_t FS_STATE; + uint16_t ON_ERR; + uint16_t VERSION_MINOR; + uint32_t TimeLastCheck; // POSIX + uint32_t CheckInterval; //POSIX + uint32_t OS_ID; // OS the FS was created with + uint32_t VERSION_MAJOR; + uint16_t UIDReservedBlocks; + uint16_t GIDReservedBlocks; +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/filesystem/FAT/BiosParameterBlock.h b/source/kernel/filesystem/FAT/BiosParameterBlock.h new file mode 100644 index 0000000..3bf2de3 --- /dev/null +++ b/source/kernel/filesystem/FAT/BiosParameterBlock.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include "./ExtendBootRecord.h" + +struct BiosParameterBlock { + uint8_t BootLoaderCodeSection [3]; + uint8_t OEM_id [8]; + uint16_t BytesPerSector ; // I suspect would be 512 + uint8_t SectorsPerCluster ; + uint16_t ReservedSectors; + uint8_t NumberOfFileAllocationTables; // Probably equals 2 + uint16_t NumberOfDirectoryEntries; // Root directory must contain entire sectors + uint16_t TotalSectorsInLogicalVolume ; // 0 means >65535 sectors in volume , actual count can be found in LargeSectorCount + uint8_t MediaDescriptor ; // Indication the media descriptor type + uint16_t NumberOfSectorsPerFAT;// only in FAT12 / FAT 16 + uint16_t NumberOfSectorsPerTrack; + uint16_t NumberOfHeadsOnMedia; + uint32_t NumberOfHiddenSectors; + uint32_t LargeSectorCount; + ExtendedBootRecord_FAT16 ebpb; +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/filesystem/FAT/DirectoryEntry.h b/source/kernel/filesystem/FAT/DirectoryEntry.h new file mode 100644 index 0000000..c3e48ec --- /dev/null +++ b/source/kernel/filesystem/FAT/DirectoryEntry.h @@ -0,0 +1,19 @@ +#pragma once +#include + +struct DirectoryEntry { + uint8_t filename [8]; + uint8_t Extension [3]; + uint8_t attribute; + uint8_t Reserved; + uint8_t creation; + uint16_t CreationTime; + uint16_t CreationDate; + uint16_t LastAccessDate; + uint16_t ReservedFAT32; + uint16_t LastWriteTime; + uint16_t LastWriteDate; + uint16_t StartingCluster; + uint32_t FilesizeInBytes; + +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/filesystem/FAT/ExtendBootRecord.h b/source/kernel/filesystem/FAT/ExtendBootRecord.h new file mode 100644 index 0000000..38a40b7 --- /dev/null +++ b/source/kernel/filesystem/FAT/ExtendBootRecord.h @@ -0,0 +1,32 @@ +#pragma once +#include + +struct ExtendedBootRecord_FAT16{ + uint8_t DriveNumber; + uint8_t Reserved; + uint8_t Signature; + const uint32_t VOLUME_ID_SERIAL_NUMBER; + uint8_t volume_label [11]; + uint8_t Identifier_string [8]; + uint8_t bootCode [448]; + uint16_t partitionSignature; +}__attribute__((packed)); + +struct ExtendedBootRecord_FAT32{ + uint32_t SectorsPerFAT; + uint16_t Flags; + const uint16_t FAT_VERSION_NUMBER; + uint32_t rootDirectory_clusterNumber;// Often set to 2; + uint16_t FSInfo_SectorNumber; + uint16_t backup_bpb_sectorNumber; + uint8_t Reserved [12]; + uint8_t DriveNumber; + uint8_t Reserved2; + uint8_t Signature; // must be 0x28 or 0x29 + uint32_t VOLUME_ID_SERIAL; + uint8_t volume_label[11]; + uint8_t SystemIdentifierString [8]; // ALWAYS "FAT32 " but spec says do not trust + uint8_t BootCode [420]; // NICE + uint16_t PartitionSignature; // 0xAA55 + +}__attribute__((packed)); \ No newline at end of file diff --git a/source/kernel/gdt/gdt.s b/source/kernel/gdt/gdt.s new file mode 100644 index 0000000..95859c2 --- /dev/null +++ b/source/kernel/gdt/gdt.s @@ -0,0 +1,19 @@ +.global LoadGlobalDescriptorTable + + LoadGlobalDescriptorTable: + lgdt gdtDescriptor + + movw $16, %ax + movw %ax, %ds + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + movw %ax, %ss + + jmp $8,$flush + + flush: + ret + + + diff --git a/source/kernel/gdt/gdtc.cpp b/source/kernel/gdt/gdtc.cpp new file mode 100644 index 0000000..5547dee --- /dev/null +++ b/source/kernel/gdt/gdtc.cpp @@ -0,0 +1,58 @@ +#include "gdtc.h" +#include "../terminal/kterm.h" + +#define NULL_SEGMENT 0 +#define KERNEL_CODE_SEGMENT 1 +#define KERNEL_DATA_SEGMENT 2 +#define USER_CODE_SEGMENT 3 +#define USER_DATA_SEGMENT 4 + +SegmentDescriptor GlobalDescriptorTable[5]; +GlobalDescriptorTableDescriptor gdtDescriptor; + +void add_descriptor(int which , unsigned long base, unsigned long limit, unsigned char access, unsigned char granularity ){ + GlobalDescriptorTable[which].base_low = (base & 0xFFFF ); + GlobalDescriptorTable[which].base_middle = (base >> 6) & 0xFF; + GlobalDescriptorTable[which].base_high = (base >> 24) & 0xFF; + + GlobalDescriptorTable[which].limit_low = (limit & 0xFFFF); + GlobalDescriptorTable[which].granularity = ((limit >> 16) & 0x0F); + + GlobalDescriptorTable[which].granularity |= (granularity & 0xF0); + GlobalDescriptorTable[which].access = access; + + +} + + + + +void initGDT(){ + +#ifdef __VERBOSE__ + printf("Init GDT!\n"); +#endif + // NULL segment + add_descriptor(NULL_SEGMENT, 0,0,0,0); + + // Kernel Code Segment + add_descriptor(KERNEL_CODE_SEGMENT, 0, 0xFFFFFFFF, 0x9A, 0xCF); + + // Kernel Data Segment + add_descriptor(KERNEL_DATA_SEGMENT, 0, 0xFFFFFFFF, 0x92, 0xCF); + + // User Code Segment + // TODO: + + // User Data Segement + // TODO: + + // init Gdt Descriptor + gdtDescriptor.limit = ((sizeof(SegmentDescriptor ) * 5 ) - 1); + gdtDescriptor.base = (unsigned int) &GlobalDescriptorTable; + + + + LoadGlobalDescriptorTable(); + +} diff --git a/source/kernel/gdt/gdtc.h b/source/kernel/gdt/gdtc.h new file mode 100644 index 0000000..548bc5e --- /dev/null +++ b/source/kernel/gdt/gdtc.h @@ -0,0 +1,27 @@ +#include + + +struct SegmentDescriptor { + unsigned short limit_low; + unsigned short base_low; + unsigned char base_middle; + unsigned char access; + unsigned char granularity; + unsigned char base_high; +}__attribute__((packed)); + + +struct GlobalDescriptorTableDescriptor{ + unsigned short limit; + unsigned int base; +}__attribute__((packed)); + +extern SegmentDescriptor GlobalDescriptorTable[]; +extern GlobalDescriptorTableDescriptor gdtDescriptor; + + +void add_descriptor(int which , unsigned long base, unsigned long limit, unsigned char access, unsigned char granularity ); + + +extern "C" void LoadGlobalDescriptorTable(); +void initGDT(); diff --git a/source/kernel/interrupts/idt/idt.cpp b/source/kernel/interrupts/idt/idt.cpp index 7ee01da..abb9940 100644 --- a/source/kernel/interrupts/idt/idt.cpp +++ b/source/kernel/interrupts/idt/idt.cpp @@ -2,6 +2,8 @@ #include "../../drivers/pit/pit.h" #include "../../drivers/ps-2/keyboard.h" #include "../../cpu.h" +#include "../../drivers/ps-2/keyboard.h" + IDT_entry idt_table[256]; IDT_ptr idt_ptr; diff --git a/source/kernel/kernel.cpp b/source/kernel/kernel.cpp index 8049eb5..685b344 100644 --- a/source/kernel/kernel.cpp +++ b/source/kernel/kernel.cpp @@ -1,4 +1,6 @@ -#include "lib/string.h" +extern "C"{ + #include "../lib/include/string.h" +} #include "definitions.h" #include "prekernel/bootstructure.h" @@ -6,14 +8,20 @@ #include "drivers/vga/VBE.h" #include "drivers/pit/pit.h" -#include "memory/PhysicalMemoryManager.h" +#include "memory/memory.h" #include "memory/VirtualMemoryManager.h" #include "memory/KernelHeap.h" #include "memory/gdt/gdtc.h" +#include "drivers/acpi/rsdp.h" +#include "drivers/ide/ide.h" +#include "drivers/ata/ataDevice.h" +#include "PartitionTable/MBR/MasterBootRecord.h" #include "interrupts/idt/idt.h" - -#include "io.h" +#include "filesystem/FAT/BiosParameterBlock.h" +#include "filesystem/FAT/DirectoryEntry.h" +#include "drivers/io/io.h" +#include "drivers/pci/pci.h" #include "cpu.h" #include "serial.h" #include "time.h" @@ -32,6 +40,152 @@ extern "C" void kernel_main () */ printf("|=== BarinkOS ===|\n"); startSuperVisorTerminal(); + + RSDPTR* rsd = FindRSD(); + RSDT* rsd_table = getRSDT(rsd); + + + // Enumerate the PCI bus + PCI_Enumerate(); + TestIDEController(); + + int devNumber = 0 ; + for ( auto device : ide_devices){ + if (!device.Reserved) + continue; + printf("Device %d\n" , devNumber); + printf (" Device on Channel: (0x%x) %s\n" ,device.Channel, device.Channel == 0 ? "Primary" : "Secondary"); + printf (" Device drive:(0x%x) %s\n" , device.Drive, device.Drive? "Slave" : "Master"); + printf (" Device Type:(0x%x) %s\n" , device.Type, device.Type ? "ATAPI" : "ATA"); + devNumber ++; + + } + + enum BUS_PORT { + Primary= 0x1f0, + Secondary = 0x170 + }; + + + + ATA_DEVICE::Identify((uint16_t) BUS_PORT::Primary, DEVICE_DRIVE::MASTER); + + const int C = 0; + const int H = 0; + const int HPC = 16; + const int SPT = 63; + + int S = 1; + uint32_t LBA = (C*HPC+H) * SPT + (S-1); + printf("LBA: %d\n" , LBA); + uint16_t buffer [256]; + + + ATA_DEVICE::Read(BUS_PORT::Primary, DEVICE_DRIVE::MASTER, LBA, buffer); + + MBR* mbr = (MBR*) buffer; + + printf("BootSector: 0x%x\n", mbr->ValidBootsector ); + for( int i = 0 ; i < 4 ; i ++){ + PartitionTableEntry PT = mbr->TableEntries[i]; + + printf("Partition %d [ %d sectors, PartitionType: %x, 0x%x, \nLBA Start: 0x%x ]\n" , + i, PT.Number_sectors_inPartition, PT.PartitionType, mbr->uniqueID, PT.LBA_partition_start ); + } + + // Find the BiosParameter block + uint16_t biosparameterblock[256]; + ATA_DEVICE::Read(BUS_PORT::Primary, DEVICE_DRIVE::MASTER, mbr->TableEntries[0].LBA_partition_start, biosparameterblock); + + BiosParameterBlock* bpb = (BiosParameterBlock*) biosparameterblock; + + + printf("\nBPB: Bytes per Sector %d\n", bpb->BytesPerSector ); + printf("OEM ID: %s\n", bpb->OEM_id); + printf("Bytes per sector: %d\n", bpb->BytesPerSector); + printf("Sectors per cluster: %d\n", bpb->SectorsPerCluster); + printf("Reserved sectors: %d\n", bpb->ReservedSectors); + printf("Number of FAT: %d\n", bpb->NumberOfFileAllocationTables); + printf("Number of Dir entries: %d\n", bpb->NumberOfDirectoryEntries); + printf("Total Sectors in volume: %d\n", bpb->TotalSectorsInLogicalVolume); + printf("Sectors per FAT: %d\n", bpb->NumberOfSectorsPerFAT); + + + + + /** + * @brief File Allocation Table + */ + + + uint32_t FATAddress = mbr->TableEntries[0].LBA_partition_start + bpb->ReservedSectors ; + uint16_t FAT[256]; + ATA_DEVICE::Read(BUS_PORT::Primary, DEVICE_DRIVE::MASTER, FATAddress, FAT ); + + // Show data in terminal + for(int i = 0; i < 256; i++ ) { + printf("%x ", FAT[i]); + } + kterm_put('\n'); + + + uint32_t RootDirectoryRegion = FATAddress + ( bpb->NumberOfFileAllocationTables * bpb->NumberOfSectorsPerFAT ); + uint32_t DataRegion = RootDirectoryRegion + ((bpb->NumberOfDirectoryEntries * 32) / bpb->BytesPerSector ); + + uint16_t data2 [256]; + ATA_DEVICE::Read(BUS_PORT::Primary, DEVICE_DRIVE::MASTER, RootDirectoryRegion, data2 ); + DirectoryEntry* RootDirectory = (DirectoryEntry*) data2; + // List files in root + for(int i= 0; i < bpb->NumberOfDirectoryEntries ; i++ ) + { + DirectoryEntry* entry = (DirectoryEntry*)((uint32_t) RootDirectory + (i * sizeof(DirectoryEntry))); + + if( entry->filename[0] == (uint8_t) 0x00 ) + break; // There are no more entries in this directory or the entry is free + + if( entry->attribute & 0x01 == 0x01 || entry->attribute & 0x20 == 0x20) + continue; // Skip listing if hidden or Achieve flag is set + + // Print the filename; + for( int n = 0; n < 8; n++ ){ + if(entry->filename[n] == 0x20) + break; + kterm_put(entry->filename[n]); + }kterm_put('\n'); + + for( int n = 0; n < 3; n++){ + kterm_put(entry->Extension[n]); + }kterm_put('\n'); + + printf("Attribute: %x \n" , entry->attribute); + printf("FileSize: %d Bytes\n", entry->FilesizeInBytes); + + if( entry->FilesizeInBytes != 0x0 || entry->attribute & 0x8 == 0x0){ + printf("Show contents"); + + printf( "Start cluster of the file: 0x%x\n" , entry->StartingCluster); + + printf("IS it only 1 cluster? %s\n" , FAT[i] == 0xFFFF? "Yes": "No" ); + + uint32_t sector = DataRegion + ((entry->StartingCluster - 0x02 ) * bpb->SectorsPerCluster); + + + uint16_t dataBlob [256]; + ATA_DEVICE::Read(BUS_PORT::Primary, DEVICE_DRIVE::MASTER, sector, dataBlob ); + for( int n = 0; n < 256; n++) + { + kterm_put(dataBlob[n] & 0x00ff); + + kterm_put(dataBlob[n] >> 8); + }kterm_put('\n'); + + + } + + printf("======================\n"); + + + } } @@ -82,4 +236,4 @@ extern "C" void early_main() kernel_main(); -} \ No newline at end of file +} diff --git a/source/kernel/kernel.h b/source/kernel/kernel.h new file mode 100644 index 0000000..ae769df --- /dev/null +++ b/source/kernel/kernel.h @@ -0,0 +1,43 @@ +#pragma once +extern "C" +{ + #include "../lib/include/string.h" +} + + +#include "drivers/VGA/VBE.h" +#include "terminal/kterm.h" + +#include "./boot/multiboot.h" +#include "bootinfo.h" + +#include "memory/memory.h" +#include "memory/memoryinfo.h" +#include "bootcheck.h" + +#include "gdt/gdtc.h" +#include "interrupts/idt/idt.h" + +#include "drivers/IO/io.h" +#include "time.h" +#include "drivers/pit/pit.h" + +#include "cpu.h" +#include "serial.h" +#include "drivers/IO/PCI/pci.h" +#include "drivers/ide/ide.h" +#include "./drivers/IO/ata/ataDevice.h" +#include "./PartitionTable/MBR/MasterBootRecord.h" +#include "./filesystem/FAT/BiosParameterBlock.h" +#include "./filesystem/FAT/ExtendBootRecord.h" +#include "./filesystem/FAT/DirectoryEntry.h" +#include "drivers/ACPI/rsdp.h" + + +#include "time.h" +#include "supervisorterminal/superVisorTerminal.h" + +#define CHECK_FLAG(flags, bit) ((flags) & (1 <<(bit))) +#define PANIC(message) {return;} + + diff --git a/source/kernel/lib/mem.h b/source/kernel/lib/mem.h deleted file mode 100644 index 75e7cf8..0000000 --- a/source/kernel/lib/mem.h +++ /dev/null @@ -1,8 +0,0 @@ -inline void* memset (void* ptr, int value, size_t num){ - for( int i = 0; i < num; i++ ) - { - unsigned char* data = (unsigned char*)ptr+ i; - *data = (unsigned char)value; - } - return ptr; -} diff --git a/source/kernel/memory/KernelHeap.cpp b/source/kernel/memory/KernelHeap.cpp index a17ccf6..adfd2b6 100644 --- a/source/kernel/memory/KernelHeap.cpp +++ b/source/kernel/memory/KernelHeap.cpp @@ -1,6 +1,6 @@ #include "KernelHeap.h" #include "VirtualMemoryManager.h" - +extern "C" const uint32_t kernel_end; // Size of heap meta data is 5 bytes struct heap_block{ uint8_t Used; diff --git a/source/kernel/memory/PageDirectory.cpp b/source/kernel/memory/PageDirectory.cpp new file mode 100644 index 0000000..5e4ab31 --- /dev/null +++ b/source/kernel/memory/PageDirectory.cpp @@ -0,0 +1,43 @@ +#include "PageDirectory.h" + +void PageDirectory::enable() +{ + + + // https://wiki.osdev.org/Setting_Up_Paging + //set each entry to not present + // int i; + // for(i = 0; i < 1024; i++) + // { + // // This sets the following flags to the pages: + // // Supervisor: Only kernel-mode can access them + // // Write Enabled: It can be both read from and written to + // // Not Present: The page table is not present + // this->page_directory[i] = 0x00000002; + // } + + // // holds the physical address where we want to start mapping these pages to. + // // in this case, we want to map these pages to the very beginning of memory. + + // //we will fill all 1024 entries in the table, mapping 4 megabytes + // for(unsigned int i = 0; i < 1024; i++) + // { + // // As the address is page aligned, it will always leave 12 bits zeroed. + // // Those bits are used by the attributes ;) + // first_page_table[i] = (i * 0x1000) | 3; // attributes: supervisor level, read/write, present. + // } + + // // attributes: supervisor level, read/write, present + // this->page_directory[0] = ((unsigned int)first_page_table) | 3; + + printf("Enable Paging!\n"); + + loadPageDirectory(this->page_directory); + enablePaging(); +} + + +void PageDirectory::MapPhysicalToVirtualAddress ( address_t PAddress , address_t VAddress, uint32_t size ) +{ + +} diff --git a/source/kernel/memory/PageDirectory.h b/source/kernel/memory/PageDirectory.h new file mode 100644 index 0000000..c5c5479 --- /dev/null +++ b/source/kernel/memory/PageDirectory.h @@ -0,0 +1,31 @@ +#pragma once +#include +#include "./memory.h" +#include "./../terminal/kterm.h" +#define KB 1024 + + +typedef uintptr_t address_t; + +static const int MAX_PAGES = 1024 * KB; // 4GB , 4kB/page +static volatile address_t pmem_stack[MAX_PAGES]; +static volatile address_t pmem_stack_top = MAX_PAGES; // top down allocation + +extern "C" void loadPageDirectory (uint32_t* addr ); +extern "C" void enablePaging(); + +struct page_directory_entry {}; +struct page_table_entry{}; + + + +class PageDirectory { + public: + void enable (); + void MapPhysicalToVirtualAddress ( address_t PAddress , address_t VAddress, uint32_t size ); + + private: + uint32_t page_directory[1024] __attribute__((aligned(4096))); // align on 4 kiloByte pages + uint32_t first_page_table[1024] __attribute__((aligned(4096))); // align on 4 kiloByte pages + +}; \ No newline at end of file diff --git a/source/kernel/memory/PhysicalMemoryManager.h b/source/kernel/memory/PhysicalMemoryManager.h index e68b33d..9aa9c15 100644 --- a/source/kernel/memory/PhysicalMemoryManager.h +++ b/source/kernel/memory/PhysicalMemoryManager.h @@ -2,7 +2,7 @@ #include #include "../prekernel/bootstructure.h" #include "../terminal/kterm.h" -#include "../lib/mem.h" +#include "../../lib/include/mem.h" #include "../bitmap.h" #define BLOCK_SIZE 4092 diff --git a/source/kernel/memory/memory.cpp b/source/kernel/memory/memory.cpp new file mode 100644 index 0000000..b72e786 --- /dev/null +++ b/source/kernel/memory/memory.cpp @@ -0,0 +1,142 @@ +#include "./memory.h" +uint32_t* memoryBitMap; +/* + +*/ +void PhysicalMemory::setup( MemoryInfo* memory) { + + // calculate the maximum number of blocks + max_blocks = KB_TO_BLOCKS(memory->TotalMemory); + + used_blocks = 0; + + memoryBitMap = (uint32_t*) 0x00a00000; + + + printf("Maximum Number of blocks: 0x%x, Number of bytes for memMap: 0x%x\n", max_blocks , (max_blocks/8)); + + //Size of memory map + uint32_t memMap_size = (max_blocks / 8 ) ; + + printf("Memory Map size: 0x%x\n", memMap_size ); + printf("size of int in bytes: 0x%x \n" , sizeof(int)); + + // Set all places in memory as free + memset(memoryBitMap, 0xFF, memMap_size ); +} + +// NOTE: this can only give blocks of 4kb at a time! +void* PhysicalMemory::allocate_block() { + uint8_t blocks_available = max_blocks - used_blocks; + // Are there any blocks available? + if( blocks_available <= 0) + { + printf("No blocks available. Blocks Delta: 0x%x\n", blocks_available); + return 0; + } + + // Find 1 free block somewhere + int free_block_index = bitmap_first_unset(memoryBitMap, (max_blocks /8) /*memMap Size*/ ); + + + + if(free_block_index == -1) + { + printf("Could not find a good block!\n"); + // Could not find a block + return (void*)0xFFFF; + } + + if(free_block_index == 0) + printf("Somethings wrong!!!\n"); + + // Set the block to be used! + bitmap_unset(memoryBitMap, free_block_index); + // Increase the used_block count! + used_blocks++; + printf("used blocks: 0x%x\n", used_blocks); + // return the pointer to the physical address + return (void*) (BLOCK_SIZE * free_block_index); +} + + +void PhysicalMemory::free_block(void* p) { + // If it is a null pointer we don't need to do anything. + if(p==0) { + return; + } + // calculate the index into the bitmap + int index = ((uint32_t) p) / BLOCK_SIZE; + + // set the block to be free + bitmap_set(memoryBitMap, index); + used_blocks--; + printf("used blocks: 0x%x, after free\n", used_blocks); + +} + + + +void PhysicalMemory::allocate_region(uint32_t startAddress, uint32_t size) { + // every bit should be 4KiB + // every byte is 8*4KiB = 32KiB + + int NumberOfBlocksToAllocate = ( size / 1024) / 4 / 8 + 1; + int startBlock = (startAddress / 1024) / 4 / 8 ; + + // printf("NumberOfBlocksToAllocate: 0x%x\n", NumberOfBlocksToAllocate); + //printf( "start block: 0x%x\n" , startBlock); + for( int i = 0; i < NumberOfBlocksToAllocate; i++) + { + + //printf("ALLOCATE BLOCK: 0x%x\n" , startBlock + i ); + bitmap_unset(memoryBitMap, startBlock+ i); + used_blocks++; + } + + +} +void PhysicalMemory::deallocate_region(uint32_t StartAddress , uint32_t size ) { + // NOT IMPLEMENTED YET +} + + +void mapMultibootMemoryMap( MemoryInfo* memInfo , multiboot_info_t *mbt) { + printf("mmap_addr = 0x%x, mmap_length = 0x%x\n", + (unsigned) mbt->mmap_addr, (unsigned) mbt->mmap_length); + multiboot_memory_map_t *mmap = (multiboot_memory_map_t*) mbt->mmap_addr; + + for (; (unsigned long) mmap < mbt->mmap_addr + mbt->mmap_length; mmap = (multiboot_memory_map_t *) ((unsigned long) mmap + mmap->size + sizeof(mmap->size))){ + + if ( mmap->type == MULTIBOOT_MEMORY_AVAILABLE){ + + memInfo->TotalMemory += mmap->len; + } else { + memInfo->ReservedMemory += mmap->len; + } + + print_Multiboot_memory_Map(mmap); + + } + +} + + +/** + * @brief Debug Verbose functions + * + * @param mmap + */ + +void print_Multiboot_memory_Map(multiboot_memory_map_t* mmap) { + printf( + "size = 0x%x, base_addr = 0x%x%08x, length = 0x%x%08x, type = 0x%x\n", + (unsigned) mmap->size, + (unsigned) (mmap->addr >> 32), + (unsigned) (mmap->addr & 0xffffffff), + (unsigned) (mmap->len >> 32), + (unsigned) (mmap->len & 0xffffffff), + (unsigned) mmap->type + ); +} + diff --git a/source/kernel/memory/memory.h b/source/kernel/memory/memory.h new file mode 100644 index 0000000..ea609ac --- /dev/null +++ b/source/kernel/memory/memory.h @@ -0,0 +1,45 @@ +#pragma once +#include +#include + +#include "memoryinfo.h" +#include "../prekernel/multiboot.h" +#include "../terminal/kterm.h" +#include "../../lib/include/mem.h" +#include "../bitmap.h" + +#define BLOCK_SIZE 4092 +#define BLOCKS_PER_WORD 32 // A word is 16 bit in x86 machines according to my google search results! + +#define KB_TO_BLOCKS(x) (x / BLOCK_SIZE) +#define IS_ALIGNED(addr, align) !((addr) & ~((align) - 1)) +#define ALIGN(addr, align) (((addr) & ~((align) - 1 )) + (align)) + +void initialise_available_regions(uint32_t memoryMapAddr, uint32_t memoryMapLastAddr, uint32_t* memoryBitMap, int* used_blocks); + +extern uint32_t* memoryBitMap; + +class PhysicalMemory +{ + public: + void setup(MemoryInfo* memory); + void destroy(); + void free_block(void* ptr); + void* allocate_block(); + void allocate_region(uint32_t, uint32_t); + void deallocate_region(uint32_t , uint32_t ); + + private: + size_t pmmap_size; + size_t max_blocks; + int used_blocks; +}; + +void mapMultibootMemoryMap( MemoryInfo* memInfo , multiboot_info_t *mbt); + +/** + * @brief Debug Verbose Functions + * + * @param mmap + */ +void print_Multiboot_memory_Map(multiboot_memory_map_t* mmap); diff --git a/source/kernel/memory/memoryinfo.h b/source/kernel/memory/memoryinfo.h new file mode 100644 index 0000000..9bbb626 --- /dev/null +++ b/source/kernel/memory/memoryinfo.h @@ -0,0 +1,20 @@ +#pragma once +#include +#include + +struct MemoryArea{ + void* StartAddress; + size_t Size; + unsigned int type; + MemoryArea* Next; + +}__attribute__((packed)); + +struct MemoryInfo { + uint32_t TotalMemory; + uint32_t ReservedMemory; + MemoryArea* MemoryRegionList; +}__attribute__((packed)); + + + diff --git a/source/kernel/memory/paging.s b/source/kernel/memory/paging.s new file mode 100644 index 0000000..fa25003 --- /dev/null +++ b/source/kernel/memory/paging.s @@ -0,0 +1,20 @@ +.globl enablePaging +enablePaging: + push %ebp + mov %esp, %ebp + mov %cr0, %eax + or $0x80000000, %eax + mov %eax, %cr0 + mov %ebp, %esp + pop %ebp + ret + +.globl loadPageDirectory +loadPageDirectory: + push %ebp + mov %esp, %ebp + mov 8(%esp), %eax + mov %eax, %cr3 + mov %ebp, %esp + pop %ebp + ret diff --git a/source/kernel/serial.h b/source/kernel/serial.h index 6494a36..ca72be9 100644 --- a/source/kernel/serial.h +++ b/source/kernel/serial.h @@ -1,7 +1,7 @@ #pragma once #include "terminal/kterm.h" -#include "io.h" +#include "drivers/io/io.h" #define PORT 0x3f8 static int init_serial() { @@ -30,27 +30,27 @@ static int init_serial() { return 0; } -int is_transmit_empty() { +inline int is_transmit_empty() { return inb(PORT + 5) & 0x20; } -void write_serial(char a) { +inline void write_serial(char a) { while (is_transmit_empty() == 0); outb(PORT,a); } -int serial_received() { +inline int serial_received() { return inb(PORT + 5) & 1; } -char read_serial() { +inline char read_serial() { while (serial_received() == 0); return inb(PORT); } -void print_serial(const char* string ){ +inline void print_serial(const char* string ){ for(size_t i = 0; i < strlen(string); i ++){ write_serial(string[i]); } diff --git a/source/kernel/supervisorterminal/superVisorTerminal.cpp b/source/kernel/supervisorterminal/superVisorTerminal.cpp index 74e5dcb..51aeff9 100644 --- a/source/kernel/supervisorterminal/superVisorTerminal.cpp +++ b/source/kernel/supervisorterminal/superVisorTerminal.cpp @@ -1,7 +1,7 @@ #include "superVisorTerminal.h" - +bool isRunning = true; void startSuperVisorTerminal(){ - while (true){ + while (isRunning){ printf("SUPERVISOR:>$ " ); int characterCount = 0; @@ -38,11 +38,18 @@ void startSuperVisorTerminal(){ { // Show memory layout printf("========= Memory ==========\n"); - printf("Not Available!\n"); printf("Kernel MemoryMap:\n"); - printf("Frames used: -- \n"); - printf("Available Memory:-- \n"); - printf("Reserved Memory: -- bytes\n"); + printf("kernel: 0x%x - 0x%x\n", &kernel_begin , &kernel_end); + printf("Frames used: 0x%x blocks of 4 KiB\n", 0); + const int bytesInGiB = 1073741824; + //int64_t bytesLeft = (bootinfo->memory->TotalMemory % bytesInGiB) / bytesInGiB; + //int64_t effectiveNumberOfGib = bootinfo->memory->TotalMemory / bytesInGiB; + + //int64_t GiBs = effectiveNumberOfGib + bytesLeft; + + //printf("Available Memory: %d bytes, %d GiB\n", bootinfo->memory->TotalMemory, GiBs ); + //printf("Reserved Memory: %d bytes\n", bootinfo->memory->ReservedMemory); + } else if(strncmp("TEST", command, characterCount) == 0) { @@ -56,11 +63,15 @@ void startSuperVisorTerminal(){ printf("Kernel v%d\n", 0); } - else if(strncmp("CLEAR", command, characterCount) == 0) + else if(strncmp("CLEAR", command, characterCount) == 0) { kterm_init(); printf("|=== BarinkOS ===|\n"); } + else if(strncmp("FAT", command, characterCount) == 0){ + isRunning = false; + continue; + } else { printf("Unknown command\n"); diff --git a/source/kernel/supervisorterminal/superVisorTerminal.h b/source/kernel/supervisorterminal/superVisorTerminal.h index 796f6ac..3ca186e 100644 --- a/source/kernel/supervisorterminal/superVisorTerminal.h +++ b/source/kernel/supervisorterminal/superVisorTerminal.h @@ -4,6 +4,8 @@ #include "../drivers/pit/pit.h" #include "../drivers/ps-2/keyboard.h" #include "../memory/PhysicalMemoryManager.h" -#include "../lib/string.h" +extern "C" { + #include "../../lib/include/string.h" +} void startSuperVisorTerminal(); \ No newline at end of file diff --git a/source/kernel/terminal/kterm.h b/source/kernel/terminal/kterm.h index 1d63389..7ac6d27 100644 --- a/source/kernel/terminal/kterm.h +++ b/source/kernel/terminal/kterm.h @@ -4,9 +4,10 @@ #include #include "../drivers/vga/colors.h" -#include "../io.h" - -#include "../lib/string.h" +#include "../drivers/io/io.h" +extern "C" { +#include "../../lib/include/string.h" +} void kterm_init(); diff --git a/source/kernel/time.h b/source/kernel/time.h index 0f4f12c..9d0003a 100644 --- a/source/kernel/time.h +++ b/source/kernel/time.h @@ -1,5 +1,5 @@ #pragma once -#include "io.h" +#include "drivers/io/io.h" #define CURRENT_YEAR 2021 diff --git a/source/kernel/vfs/File.h b/source/kernel/vfs/File.h new file mode 100644 index 0000000..5a76c48 --- /dev/null +++ b/source/kernel/vfs/File.h @@ -0,0 +1,9 @@ +#pragma once + +class File { + +public: + virtual const File* Open () const ; // TODO: figure out a proper return value + virtual const char* Read() const; + virtual void Write(); +}; diff --git a/source/kernel/vfs/VFS.cpp b/source/kernel/vfs/VFS.cpp new file mode 100644 index 0000000..8eca77a --- /dev/null +++ b/source/kernel/vfs/VFS.cpp @@ -0,0 +1,50 @@ +#include "VFS.h" +/* + * TODO: Implement this!! + * + */ + + + +void VirtualFileSystem::Initialize(FS* root) +{ + root = root; +} + +void VirtualFileSystem::Open(const char* path) +{ + /* + What does this mean? + 1. Parse the path string + 2. Traverse the graph (Finding the correct Node) + 3. Create some kind of open file pointer thingy + */ +} + +void VirtualFileSystem::Read() +{ + // NOTE: we need some way to know what file we wish to read from +} + +void VirtualFileSystem::Write() +{ + // NOTE: we need some way to know what file we wish to write to +} + +void VirtualFileSystem::Mount(const char* path, FS* FileSystem) +{ + /* + What does this mean? + 1. Parse the path string + 2. Add a node to our internal graph + */ +} + +void VirtualFileSystem::UnMount(FS* FileSystem) +{ + /* + What does this mean? + 1. Parse the path string + 2. Remve a node to our internal graph + */ +} \ No newline at end of file diff --git a/source/kernel/vfs/VFS.h b/source/kernel/vfs/VFS.h new file mode 100644 index 0000000..b525cc2 --- /dev/null +++ b/source/kernel/vfs/VFS.h @@ -0,0 +1,29 @@ +#pragma once + +class VirtualFileSystem{ +public: + void Initialize( FS* root); + void Open (const char* path); + void Read(); + void Write(); + + void Mount(const char* path,FS* FileSystem); + void UnMount(FS* FileSystem); + +private: + FS* root; + + +}; + +struct FS +{ + const char* name ; + int DeviceID; + int ManufacturerID; + FS* next; + char**(Read)(); + void*(Write)(); + void*(Open)(); +}; + diff --git a/source/lib/include/mem.h b/source/lib/include/mem.h new file mode 100644 index 0000000..83216f6 --- /dev/null +++ b/source/lib/include/mem.h @@ -0,0 +1,30 @@ +#pragma once +// NOTE: These should not be inline +inline void* memset (void* ptr, int value, size_t num){ + for( int i = 0; i < num; i++ ) + { + unsigned char* data = (unsigned char*)ptr+ i; + *data = (unsigned char)value; + } + return ptr; +} + + + +inline int memcmp( const void* ptr1, const void* ptr2, size_t num) + { + const unsigned char * cs = (const unsigned char*) ptr1; + const unsigned char * ct = (const unsigned char*) ptr2; + + + for (int i = 0 ; i < num ; i++, cs++, ct++ ){ + if( *cs < *ct){ + return -1; + } else if( *cs > *ct){ + return 1; + } + } + + return 0; + + } \ No newline at end of file diff --git a/source/kernel/lib/string.cpp b/source/lib/include/string.c similarity index 99% rename from source/kernel/lib/string.cpp rename to source/lib/include/string.c index a45162c..672d1a8 100644 --- a/source/kernel/lib/string.cpp +++ b/source/lib/include/string.c @@ -8,8 +8,6 @@ size_t strlen(const char* str) { return len; } - - int strncmp ( const char* str1, const char* str2, size_t num ){ for( int i = 0; i < num ; i++){ @@ -25,4 +23,4 @@ int strncmp ( const char* str1, const char* str2, size_t num ){ } return 0; -} \ No newline at end of file +} diff --git a/source/kernel/lib/string.h b/source/lib/include/string.h similarity index 50% rename from source/kernel/lib/string.h rename to source/lib/include/string.h index fb8d746..7009681 100644 --- a/source/kernel/lib/string.h +++ b/source/lib/include/string.h @@ -1,6 +1,4 @@ #pragma once #include size_t strlen(const char* str); - - int strncmp ( const char* str1, const char* str2, size_t num ); \ No newline at end of file