Compare commits
4 Commits
767dac7e73
...
BasicGraph
| Author | SHA1 | Date | |
|---|---|---|---|
| f0651ef972 | |||
| 405b9468d5 | |||
| 006c902200 | |||
| 2eca761edc |
36
Makefile
36
Makefile
@ -5,22 +5,7 @@ CC = ${HOME}/opt/cross/bin/i686-elf-gcc
|
||||
CPP = ${HOME}/opt/cross/bin/i686-elf-g++
|
||||
CFLAGS = -ffreestanding -O2 -Wall -Wextra
|
||||
|
||||
OFILES = \
|
||||
$(BUILD_DIR)/boot.o \
|
||||
$(BUILD_DIR)/kterm.o \
|
||||
$(BUILD_DIR)/kernel.o \
|
||||
$(BUILD_DIR)/PhysicalMemoryManager.o \
|
||||
$(BUILD_DIR)/io.o \
|
||||
$(BUILD_DIR)/PageDirectory.o \
|
||||
$(BUILD_DIR)/gdtc.o \
|
||||
$(BUILD_DIR)/idt.o \
|
||||
$(BUILD_DIR)/pci.o \
|
||||
$(BUILD_DIR)/pic.o \
|
||||
$(BUILD_DIR)/string.o \
|
||||
$(BUILD_DIR)/pcidevice.o \
|
||||
$(BUILD_DIR)/atapiDevice.o
|
||||
|
||||
|
||||
OFILES = $(BUILD_DIR)/boot.o $(BUILD_DIR)/window.o $(BUILD_DIR)/cursor.o $(BUILD_DIR)/kterm.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/PhysicalMemoryManager.o $(BUILD_DIR)/io.o $(BUILD_DIR)/vesa.o $(BUILD_DIR)/PageDirectory.o $(BUILD_DIR)/gdtc.o $(BUILD_DIR)/idt.o $(BUILD_DIR)/pic.o $(BUILD_DIR)/string.o
|
||||
|
||||
SRC_DIR = src
|
||||
BUILD_DIR = build
|
||||
@ -51,10 +36,9 @@ iso: clean_iso clean build
|
||||
grub-mkrescue -o build/barinkOS.iso root
|
||||
|
||||
test:
|
||||
$(EMULATOR) -kernel $(BUILD_DIR)/myos.bin -serial stdio -vga std -display gtk -m 2G -cpu core2duo
|
||||
|
||||
$(EMULATOR) -kernel $(BUILD_DIR)/myos.bin -serial mon:stdio -vga std -display gtk -m 2G -cpu core2duo # -monitor stdio
|
||||
test_iso:
|
||||
$(EMULATOR) -cdrom $(BUILD_DIR)/barinkOS.iso -serial stdio -vga std -display gtk -m 2G -cpu core2duo
|
||||
$(EMULATOR) -cdrom build/barinkOS.iso -serial mon: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 \
|
||||
@ -68,7 +52,7 @@ clean:
|
||||
rm -f $(BUILD_DIR)/myos.bin $(INTERNAL_OBJS)
|
||||
|
||||
$(BUILD_DIR)/kernel.o:
|
||||
$(CPP) -c $(SRC_DIR)/kernel/kernel.cpp -o $(BUILD_DIR)/kernel.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
$(CPP) -c $(SRC_DIR)/kernel/kernel.cpp -o $(BUILD_DIR)/kernel.o $(CFLAGS) -fno-exceptions -fno-rtti -fpermissive
|
||||
|
||||
$(BUILD_DIR)/kterm.o:
|
||||
$(CPP) -c $(SRC_DIR)/kernel/tty/kterm.cpp -o $(BUILD_DIR)/kterm.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
@ -104,11 +88,11 @@ $(BUILD_DIR)/string.o:
|
||||
$(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/pci.cpp -o $(BUILD_DIR)/pci.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
$(BUILD_DIR)/vesa.o:
|
||||
$(CPP) -c $(SRC_DIR)/kernel/drivers/vesa/vesa.cpp -o $(BUILD_DIR)/vesa.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
|
||||
$(BUILD_DIR)/pcidevice.o:
|
||||
$(CPP) -c $(SRC_DIR)/kernel/pci/pciDevice.cpp -o $(BUILD_DIR)/pcidevice.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
$(BUILD_DIR)/window.o:
|
||||
$(CPP) -c $(SRC_DIR)/gui/window.cpp -o $(BUILD_DIR)/window.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)/cursor.o:
|
||||
$(CPP) -c $(SRC_DIR)/gui/cursor.cpp -o $(BUILD_DIR)/cursor.o $(CFLAGS) -fno-exceptions -fno-rtti
|
||||
|
||||
10
README.md
10
README.md
@ -6,6 +6,9 @@
|
||||
|
||||
________________________
|
||||
### Screenshot(s)
|
||||
 \
|
||||
It may not look like much but I am proud of it! We are in graphics mode.
|
||||
|
||||
 \
|
||||
The first scrolling boot screen. 😲
|
||||
|
||||
@ -16,13 +19,6 @@ W.I.P - Working on interrupt handling
|
||||
|
||||
 \
|
||||
Multiboot information can be read by the kernel.
|
||||
|
||||
 \
|
||||
Enumerating the PCI bus
|
||||
|
||||
 \
|
||||
Correctly identified our ATAPI device 🎉
|
||||
|
||||
________________________
|
||||
|
||||
### The goal
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
<input type="checkbox" /> Enable SIMD Extensions (SSE)
|
||||
|
||||
## Other features I am thinking of:
|
||||
<input type="checkbox" checked/> PCI support \
|
||||
<input type="checkbox" /> PCI support \
|
||||
<input type="checkbox" /> ATA PIO Mode support \
|
||||
<input type="checkbox" /> USTAR Filesystem ( For its simplicity this is very likely the first filesystem the OS is going to support) \
|
||||
<input type="checkbox" /> ACPI support ( Or some other basic way to support shutdown, reboot and possibly hibernation ) \
|
||||
|
||||
BIN
screenshots/BarinkOS_VBE_GRAPHICS.png
(Stored with Git LFS)
Normal file
BIN
screenshots/BarinkOS_VBE_GRAPHICS.png
(Stored with Git LFS)
Normal file
Binary file not shown.
BIN
screenshots/CD-ROM_Identify.png
(Stored with Git LFS)
BIN
screenshots/CD-ROM_Identify.png
(Stored with Git LFS)
Binary file not shown.
BIN
screenshots/PCIBusEnumeration.png
(Stored with Git LFS)
BIN
screenshots/PCIBusEnumeration.png
(Stored with Git LFS)
Binary file not shown.
5
src/gui/Graphics.h
Normal file
5
src/gui/Graphics.h
Normal file
@ -0,0 +1,5 @@
|
||||
#pragma once
|
||||
|
||||
class Graphics {
|
||||
|
||||
};
|
||||
7
src/gui/Widget.h
Normal file
7
src/gui/Widget.h
Normal file
@ -0,0 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
class Widget{
|
||||
virtual void draw();
|
||||
|
||||
};
|
||||
17
src/gui/cursor.cpp
Normal file
17
src/gui/cursor.cpp
Normal file
@ -0,0 +1,17 @@
|
||||
#include "cursor.h"
|
||||
|
||||
void Cursor::draw(){
|
||||
for(int i = 0; i < this->width; i++){
|
||||
for(int j = 0; j < this->height; j++){
|
||||
if(this->bitmap[j * this->width + i] == 1 ){
|
||||
putPixel(i + this->x,j + this->y, 0xFF000000);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Cursor::Cursor(int x, int y){
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
}
|
||||
38
src/gui/cursor.h
Normal file
38
src/gui/cursor.h
Normal file
@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
#include "../kernel/drivers/vesa/vesa.h"
|
||||
|
||||
|
||||
class Cursor{
|
||||
public:
|
||||
void draw();
|
||||
Cursor(int x, int y);
|
||||
|
||||
|
||||
|
||||
private:
|
||||
int x;
|
||||
int y;
|
||||
const int width= 16;
|
||||
const int height= 10;
|
||||
const int bitmap [160] = {
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,
|
||||
|
||||
0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
|
||||
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
||||
};
|
||||
};
|
||||
33
src/gui/window.cpp
Normal file
33
src/gui/window.cpp
Normal file
@ -0,0 +1,33 @@
|
||||
#include "window.h"
|
||||
|
||||
int Window::getWidth(){
|
||||
return this->rect.width;
|
||||
}
|
||||
|
||||
int Window::getHeight(){
|
||||
return this->rect.height;
|
||||
}
|
||||
|
||||
void Window::setWidth(int& width){
|
||||
this->rect.width = width;
|
||||
}
|
||||
void Window::setHeight(int& height){
|
||||
this->rect.height = height;
|
||||
}
|
||||
|
||||
int Window::getX(){
|
||||
return this->rect.x;
|
||||
}
|
||||
|
||||
int Window::getY(){
|
||||
return this->rect.y;
|
||||
}
|
||||
|
||||
Window::Window (Rect& rect , uint32_t colour){
|
||||
this->rect = rect;
|
||||
this->Background_colour = colour;
|
||||
}
|
||||
|
||||
void Window::draw(){
|
||||
drawRect(this->getX() , this->getY() , this->getWidth() , this->getHeight() ,this->Background_colour );
|
||||
}
|
||||
37
src/gui/window.h
Normal file
37
src/gui/window.h
Normal file
@ -0,0 +1,37 @@
|
||||
#pragma once
|
||||
#include "../kernel/drivers/vesa/vesa.h"
|
||||
#include "Widget.h"
|
||||
|
||||
struct Rect {
|
||||
int width;
|
||||
int height;
|
||||
int x;
|
||||
int y;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
class Window : Widget{
|
||||
|
||||
public:
|
||||
int getX();
|
||||
int getY();
|
||||
|
||||
int getWidth();
|
||||
int getHeight();
|
||||
void setWidth(int&);
|
||||
void setHeight(int&);
|
||||
|
||||
Window (Rect& rect , uint32_t colour);
|
||||
void draw();
|
||||
|
||||
|
||||
private:
|
||||
Rect rect;
|
||||
uint32_t Background_colour;
|
||||
|
||||
|
||||
|
||||
|
||||
};
|
||||
@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "PartitionTableEntry.h"
|
||||
|
||||
struct MBR {
|
||||
uint8_t code [440];
|
||||
uint32_t uniqueID;
|
||||
uint16_t Reserved;
|
||||
PartitionTableEntry TableEntries[4];
|
||||
uint16_t ValidBootsector;
|
||||
}__attribute__((packed));
|
||||
@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
|
||||
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));
|
||||
@ -1,18 +1,27 @@
|
||||
/*
|
||||
* Multiboot
|
||||
*/
|
||||
.set ALIGN, 1<<0 /* align loaded modules on page boundaries */
|
||||
.set MEMINFO, 1<<1 /* provide memory map */
|
||||
.set FLAGS, ALIGN | MEMINFO /* this is the Multiboot 'flag' field */
|
||||
.set MAGIC, 0x1BADB002 /* 'magic number' lets bootloader find the header */
|
||||
.set CHECKSUM, -(MAGIC + FLAGS) /* checksum of above, to prove we are multiboot */
|
||||
.set ALIGN, 1<<0 /* align loaded modules on page boundaries */
|
||||
.set MEMINFO, 1<<1 /* provide memory map */
|
||||
.set VIDEO, 1<<2 /* provide video mode */
|
||||
.set FLAGS, ALIGN | MEMINFO | VIDEO /* this is the Multiboot 'flag' field */
|
||||
.set MAGIC, 0x1BADB002 /* 'magic number' lets bootloader find the header */
|
||||
.set CHECKSUM, -(MAGIC + FLAGS) /* checksum of above, to prove we are multiboot */
|
||||
|
||||
.section .multiboot
|
||||
.align 4
|
||||
.long MAGIC
|
||||
.long FLAGS
|
||||
.long CHECKSUM
|
||||
|
||||
.long 0 # unused
|
||||
.long 0 # .
|
||||
.long 0 # .
|
||||
.long 0 # .
|
||||
.long 0 # unused
|
||||
.long 0 # set graphics mode
|
||||
.long 800 # screen witdh
|
||||
.long 600 # screen height
|
||||
.long 32 # bpp
|
||||
|
||||
.section .bss
|
||||
.align 16
|
||||
|
||||
@ -1,76 +1,108 @@
|
||||
#pragma once
|
||||
#include "bootloader/multiboot.h"
|
||||
#define CHECK_FLAG(flags, bit) ((flags) & (1 <<(bit)))
|
||||
|
||||
#include "../gui/window.h"
|
||||
#include "../gui/cursor.h"
|
||||
#include "tty/kterm.h"
|
||||
|
||||
|
||||
#include "drivers/vesa/vesa.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;
|
||||
/* Set MBI to the addresss of the multiboot information structure*/
|
||||
multiboot_info_t * mbi = (multiboot_info_t *) mbt;
|
||||
|
||||
/* Print out the flags */
|
||||
printf("flags = 0x%x\n", (unsigned) mbi->flags);
|
||||
/* Print out the flags */
|
||||
printf("flags = 0x%8x\n", (unsigned) mbi->flags);
|
||||
|
||||
/* Are mem_* valid? */
|
||||
if ( CHECK_FLAG(mbi->flags,0)){
|
||||
printf("mem_lower = %uKB, mem_upper = %uKB\n");
|
||||
}
|
||||
/* Are mem_* valid? */
|
||||
if ( CHECK_FLAG(mbi->flags,0)){
|
||||
printf("mem_lower = %uKB, mem_upper = %uKB\n");
|
||||
}
|
||||
|
||||
/* is boot device valid ? */
|
||||
if (CHECK_FLAG (mbi->flags, 1)){
|
||||
printf("boot_device = 0x0%x\n", (unsigned) mbi->boot_device);
|
||||
}
|
||||
/* is boot device valid ? */
|
||||
if (CHECK_FLAG (mbi->flags, 1)){
|
||||
printf("boot_device = 0x0%x\n", (unsigned) mbi->boot_device);
|
||||
}
|
||||
|
||||
/* is the command line passed? */
|
||||
if (CHECK_FLAG ( mbi->flags,2)){
|
||||
printf("cmdline = %s\n", (char *) mbi->cmdline);
|
||||
}
|
||||
/* is the command line passed? */
|
||||
if (CHECK_FLAG ( mbi->flags,2)){
|
||||
printf("cmdline = %s\n", (char *) mbi->cmdline);
|
||||
}
|
||||
|
||||
/* Are mods_* valid? */
|
||||
if(CHECK_FLAG ( mbi->flags, 3)){
|
||||
multiboot_module_t *mod;
|
||||
uint32_t i;
|
||||
/* Are mods_* valid? */
|
||||
if(CHECK_FLAG ( mbi->flags, 3)){
|
||||
multiboot_module_t *mod;
|
||||
uint32_t i;
|
||||
|
||||
printf("mods count = %d, mods_addr = 0x%x\n", (int) mbi->mods_count, (int) mbi->mods_addr);
|
||||
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);
|
||||
}
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/* Bits 4 and 5 are mutually exclusive! */
|
||||
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG(mbi->flags, 5)){
|
||||
printf("Both bits 4 and 5 are set.\n");
|
||||
return;
|
||||
}
|
||||
/* Bits 4 and 5 are mutually exclusive! */
|
||||
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG(mbi->flags, 5)){
|
||||
printf("Both bits 4 and 5 are set.\n");
|
||||
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);
|
||||
/* 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);
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/* 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);
|
||||
/* 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);
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/* Draw diagonal blue line */
|
||||
if (CHECK_FLAG (mbt->flags, 12)){
|
||||
printf("Can draw!");
|
||||
}
|
||||
/* Draw diagonal blue line */
|
||||
if (CHECK_FLAG (mbt->flags, 11)){
|
||||
printf("Can draw!");
|
||||
|
||||
|
||||
|
||||
// Init vesa driver
|
||||
initVBEDevice(mbt);
|
||||
|
||||
// Fill screen with blue
|
||||
// colours AARRGGBB
|
||||
drawRect(0, 0 , VbeModeInfo->width,VbeModeInfo->height, 0xFF0000FF);
|
||||
|
||||
// Create two windows
|
||||
Rect rect_window1 {};
|
||||
Rect rect_window2 {};
|
||||
rect_window1.height =200;
|
||||
rect_window1.width = 300;
|
||||
rect_window1.x = 50;
|
||||
rect_window1.y = 50;
|
||||
|
||||
rect_window2.height =200;
|
||||
rect_window2.width = 300;
|
||||
rect_window2.x = 300;
|
||||
rect_window2.y = 200;
|
||||
|
||||
Window window_1 ( rect_window1, 0xFF00F0FF);
|
||||
Window window_2 (rect_window2, 0xFFAACCDD);
|
||||
|
||||
window_1.draw();
|
||||
window_2.draw();
|
||||
|
||||
Cursor cursor (70,100);
|
||||
|
||||
cursor.draw();
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,193 +0,0 @@
|
||||
#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");
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "../../io.h"
|
||||
#include "../../ide/ideCommands.h"
|
||||
#include "../../ide/sampleIDE.definitions.h"
|
||||
|
||||
#include "../../tty/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 );
|
||||
};
|
||||
|
||||
|
||||
@ -1,145 +0,0 @@
|
||||
#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");
|
||||
}
|
||||
|
||||
|
||||
@ -1,29 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "../../io.h"
|
||||
#include "../../ide/ideCommands.h"
|
||||
#include "../../ide/sampleIDE.definitions.h"
|
||||
|
||||
#include "../../tty/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 );
|
||||
|
||||
};
|
||||
136
src/kernel/drivers/vesa/vesa.cpp
Normal file
136
src/kernel/drivers/vesa/vesa.cpp
Normal file
@ -0,0 +1,136 @@
|
||||
#include "vesa.h"
|
||||
VbeInfoBlock* vbeInfo;
|
||||
vbe_mode_info_structure* VbeModeInfo;
|
||||
|
||||
void initVBEDevice(multiboot_info_t* mbt){
|
||||
print_serial("initVBEDevice");
|
||||
|
||||
vbeInfo = (VbeInfoBlock*) mbt->vbe_control_info;
|
||||
printf_serial("Signature: %s, V0x%x\n", vbeInfo->VbeSignature, vbeInfo->VbeVersion);
|
||||
|
||||
VbeModeInfo = (vbe_mode_info_structure*) mbt->vbe_mode_info;
|
||||
|
||||
printf_serial("VESA video mode info: Width: %d Height: %d BPP: %d\n", VbeModeInfo->width, VbeModeInfo->height , VbeModeInfo->bpp);
|
||||
printf_serial("VideoMemory Location: 0x%x \n", VbeModeInfo->framebuffer );
|
||||
}
|
||||
|
||||
void putPixel( int x, int y , uint32_t colour){
|
||||
// printf_serial("putPixel x: %d, y: %d\n", x, y);
|
||||
///fb + mbt->framebuffer_pitch * y + 4 * x ,NOTE: this calculation is very important
|
||||
*(uint32_t*) ( VbeModeInfo->framebuffer + VbeModeInfo->pitch * y + 4 * x ) = colour;
|
||||
}
|
||||
void drawLine(int x1, int y1, int x2, int y2, uint32_t colour ){
|
||||
print_serial("drawline\n");
|
||||
// See Bresenham's line algorithm
|
||||
int deltaX = x2 - x1;
|
||||
int deltaY = y2 - y1;
|
||||
int D = 2 * deltaY - deltaX;
|
||||
int y = y1;
|
||||
|
||||
for ( int x = x1; x < x2; x++){
|
||||
putPixel(x,y, colour);
|
||||
if( D > 0){
|
||||
y +=1;
|
||||
D = D - 2 * deltaX;
|
||||
}
|
||||
D = D + 2 * deltaY;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
void drawRect ( int x, int y, int width, int height, uint32_t colour ){
|
||||
print_serial("drawRect\n");
|
||||
for ( int i = x; i < x + width; i ++)
|
||||
{
|
||||
for(int j = y; j < y + height; j++){
|
||||
|
||||
putPixel(i,j, colour);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void blueDiagnalLineTest(multiboot_info_t* mbt){
|
||||
multiboot_uint32_t color;
|
||||
unsigned i;
|
||||
void *fb = (void *) (unsigned long) mbt->framebuffer_addr;
|
||||
|
||||
switch (mbt->framebuffer_type)
|
||||
{
|
||||
case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
|
||||
{
|
||||
unsigned best_distance, distance;
|
||||
struct multiboot_color *palette;
|
||||
|
||||
palette = (struct multiboot_color *) mbt->framebuffer_palette_addr;
|
||||
|
||||
color = 0;
|
||||
best_distance = 4*256*256;
|
||||
|
||||
for (i = 0; i < mbt->framebuffer_palette_num_colors; i++)
|
||||
{
|
||||
distance = (0xff - palette[i].blue) * (0xff - palette[i].blue)
|
||||
+ palette[i].red * palette[i].red
|
||||
+ palette[i].green * palette[i].green;
|
||||
if (distance < best_distance)
|
||||
{
|
||||
color = i;
|
||||
best_distance = distance;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
|
||||
color = ((1 << mbt->framebuffer_blue_mask_size) - 1)
|
||||
<< mbt->framebuffer_blue_field_position;
|
||||
break;
|
||||
|
||||
case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
|
||||
color = '\\' | 0x0100;
|
||||
break;
|
||||
|
||||
default:
|
||||
color = 0xffffffff;
|
||||
break;
|
||||
}
|
||||
for (i = 0; i < mbt->framebuffer_width
|
||||
&& i < mbt->framebuffer_height; i++)
|
||||
{
|
||||
switch (mbt->framebuffer_bpp)
|
||||
{
|
||||
case 8:
|
||||
{
|
||||
multiboot_uint8_t *pixel = (multiboot_uint8_t*)fb + mbt->framebuffer_pitch * i + i;
|
||||
*pixel = color;
|
||||
}
|
||||
break;
|
||||
case 15:
|
||||
case 16:
|
||||
{
|
||||
multiboot_uint16_t *pixel
|
||||
= (multiboot_uint16_t*)fb + mbt->framebuffer_pitch * i + 2 * i;
|
||||
*pixel = color;
|
||||
}
|
||||
break;
|
||||
case 24:
|
||||
{
|
||||
multiboot_uint32_t *pixel
|
||||
= (multiboot_uint32_t*)fb + mbt->framebuffer_pitch * i + 3 * i;
|
||||
*pixel = (color & 0xffffff) | (*pixel & 0xff000000);
|
||||
}
|
||||
break;
|
||||
|
||||
case 32:
|
||||
{
|
||||
multiboot_uint32_t *pixel
|
||||
= (multiboot_uint32_t*)fb + mbt->framebuffer_pitch * i + 4 * i;
|
||||
*pixel = color;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
66
src/kernel/drivers/vesa/vesa.h
Normal file
66
src/kernel/drivers/vesa/vesa.h
Normal file
@ -0,0 +1,66 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "../../bootloader/multiboot.h"
|
||||
#include "../../serial.h"
|
||||
|
||||
struct vbe_mode_info_structure{
|
||||
uint16_t attributes;
|
||||
uint8_t window_a;
|
||||
uint8_t window_b;
|
||||
uint16_t granularity;
|
||||
uint16_t window_size;
|
||||
uint16_t segment_a;
|
||||
uint16_t segment_b;
|
||||
uint32_t win_func_ptr;
|
||||
uint16_t pitch;
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
uint8_t w_char;
|
||||
uint8_t y_char;
|
||||
uint8_t planes;
|
||||
uint8_t bpp;
|
||||
uint8_t banks;
|
||||
uint8_t memory_model;
|
||||
uint8_t bank_size;
|
||||
uint8_t image_pages;
|
||||
uint8_t reserved0;
|
||||
|
||||
uint8_t red_mask;
|
||||
uint8_t red_position;
|
||||
uint8_t green_mask;
|
||||
uint8_t green_position;
|
||||
uint8_t blue_mask;
|
||||
uint8_t blue_position;
|
||||
uint8_t reserved_mask;
|
||||
uint8_t reserved_position;
|
||||
uint8_t direct_color_attributes;
|
||||
|
||||
uint32_t framebuffer;
|
||||
uint32_t off_screen_mem_off;
|
||||
uint16_t off_screen_mem_size;
|
||||
uint8_t reserved1[206];
|
||||
}__attribute__((packed));
|
||||
|
||||
struct VbeInfoBlock {
|
||||
char VbeSignature[4];
|
||||
uint16_t VbeVersion;
|
||||
uint16_t OemStringPtr;
|
||||
uint8_t Capabilities;
|
||||
uint16_t VideoModePtr;
|
||||
uint16_t TotalMemory;
|
||||
}__attribute__((packed));
|
||||
|
||||
extern VbeInfoBlock* vbeInfo;
|
||||
extern vbe_mode_info_structure* VbeModeInfo;
|
||||
|
||||
|
||||
|
||||
void initVBEDevice(multiboot_info_t* mbt);
|
||||
|
||||
void blueDiagnalLineTest(multiboot_info_t* mbt);
|
||||
|
||||
|
||||
// Primitive drawing functions
|
||||
void putPixel( int x, int y , uint32_t colour);
|
||||
void drawLine(int x1, int y1, int x2, int y2, uint32_t colour );
|
||||
void drawRect ( int x, int y, int width, int height, uint32_t colour );
|
||||
@ -1,29 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
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));
|
||||
@ -48,10 +48,15 @@ void initGDT(){
|
||||
gdtDescriptor.limit = ((sizeof(SegmentDescriptor ) * 5 ) - 1);
|
||||
gdtDescriptor.base = (unsigned int) &GlobalDescriptorTable;
|
||||
|
||||
printf("Hello GDT!\n");
|
||||
|
||||
|
||||
LoadGlobalDescriptorTable();
|
||||
|
||||
// while (true)
|
||||
// asm volatile("hlt");
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
@ -1,97 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "../pci/pciDevice.h"
|
||||
#include "../tty/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;
|
||||
|
||||
|
||||
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
#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
|
||||
@ -1,29 +0,0 @@
|
||||
#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];
|
||||
@ -1,242 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "../tty/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<t;i++)
|
||||
for(j=0;j<25000;j++)
|
||||
asm("NOP");
|
||||
}
|
||||
|
||||
void ide_write(unsigned char channel, unsigned char reg, unsigned char data){
|
||||
if (reg > 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
|
||||
|
||||
}
|
||||
@ -12,10 +12,9 @@ unsigned short inw_p(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(unsigned short ){
|
||||
// TODO: implement me!
|
||||
return 0;
|
||||
}
|
||||
unsigned int inl_p(unsigned short ){
|
||||
// TODO: implement me!
|
||||
@ -32,12 +31,9 @@ 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 ){
|
||||
|
||||
}
|
||||
|
||||
@ -12,17 +12,21 @@ 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);
|
||||
uint32_t inl( int port );
|
||||
unsigned int inl(unsigned short 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( int port , uint32_t data );
|
||||
void outl(unsigned int value, unsigned short port);
|
||||
void outl_p(unsigned int value, unsigned short port);
|
||||
|
||||
void insb(unsigned short port, void *addr,
|
||||
|
||||
@ -1,17 +1,18 @@
|
||||
#include "kernel.h"
|
||||
#define GB4 524288
|
||||
#define GB2 262144
|
||||
|
||||
int memcmp( const void* ptr1, const void* ptr2, size_t num);
|
||||
|
||||
extern "C" void kernel_main (void);
|
||||
extern "C" void putPixel(int pos_x, int pos_y, unsigned char VGA_COLOR , unsigned char addr , unsigned char pixelWidth, unsigned pitch );
|
||||
|
||||
|
||||
extern "C" void early_main(unsigned long magic, unsigned long addr){
|
||||
/** initialize terminal interface */
|
||||
kterm_init();
|
||||
/** initialize terminal interface */
|
||||
// kterm_init();
|
||||
|
||||
printf("Magic flag 0x%8x\n", magic);
|
||||
printf("Magic must be 0x%8x\n", MULTIBOOT_BOOTLOADER_MAGIC);
|
||||
if (magic != MULTIBOOT_BOOTLOADER_MAGIC){
|
||||
printf("Invalid magic number: 0x%x\n", magic);
|
||||
printf("Invalid magic number: 0x%8x\n", magic);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -34,25 +35,8 @@ extern "C" void kernel_main (void);
|
||||
initGDT();
|
||||
|
||||
|
||||
kernel_main();
|
||||
|
||||
kernel_main();
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
}
|
||||
|
||||
@ -60,43 +44,6 @@ extern "C" void kernel_main (void);
|
||||
|
||||
printf("call to init serial\n");
|
||||
init_serial();
|
||||
print_serial("Serial port initialized!");
|
||||
|
||||
|
||||
|
||||
// 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 ++;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
// ATAPI_DEVICE::isPacketDevice();
|
||||
|
||||
|
||||
|
||||
|
||||
ATAPI_DEVICE::Identify(ATA_SECONDARY, DEVICE_DRIVE::MASTER);
|
||||
|
||||
|
||||
|
||||
while (true){
|
||||
|
||||
@ -2,8 +2,6 @@
|
||||
extern "C"{
|
||||
#include "../libc/include/string.h"
|
||||
}
|
||||
|
||||
|
||||
#include "vga/VBE.h"
|
||||
#include "tty/kterm.h"
|
||||
|
||||
@ -18,11 +16,6 @@ extern "C"{
|
||||
#include "time.h"
|
||||
#include "cpu.h"
|
||||
#include "serial.h"
|
||||
#include "pci.h"
|
||||
#include "ide/ide.h"
|
||||
#include "drivers/atapi/atapiDevice.h"
|
||||
|
||||
|
||||
|
||||
#define CHECK_FLAG(flags, bit) ((flags) & (1 <<(bit)))
|
||||
#define PANIC(message) { return; }
|
||||
|
||||
@ -1,247 +1,108 @@
|
||||
#include "pci.h"
|
||||
|
||||
#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;
|
||||
}
|
||||
uint16_t ConfigReadWord (uint8_t bus, uint8_t slot, 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 */
|
||||
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);
|
||||
}
|
||||
|
||||
const char* getVendor( uint32_t VendorID){
|
||||
switch (VendorID)
|
||||
{
|
||||
case 0x8086:
|
||||
return "Intel Corporation";
|
||||
break;
|
||||
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);
|
||||
}
|
||||
|
||||
case 0x10DE:
|
||||
return "NVIDIA Corporation";
|
||||
break;
|
||||
void checkDevice (uint8_t bus, uint8_t device ) {
|
||||
uint8_t function = 0;
|
||||
|
||||
case 0x1022:
|
||||
return "Advanced Micro Devices, Inc.[AMD]";
|
||||
break;
|
||||
uint16_t vendorID = CheckVendor(bus, device);
|
||||
if (vendorID == 0xFFFF) {
|
||||
return;
|
||||
}
|
||||
|
||||
case 0x1002:
|
||||
return "Advanced Micor Devices, Inc.[AMD/ATI]";
|
||||
break;
|
||||
|
||||
default:
|
||||
return "Vendor Unkown";
|
||||
break;
|
||||
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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
uint32_t ConfigReadWord ( PCIBusAddress& PCIDeviceAddress , uint8_t offset){
|
||||
outl(CONFIG_ADDRESS , PCIDeviceAddress.getAddress() | offset );
|
||||
return inl(CONFIG_DATA);
|
||||
|
||||
void checkFunction (uint8_t bus, uint8_t device, uint8_t function ){
|
||||
uint8_t baseClass;
|
||||
uint8_t subClass;
|
||||
uint8_t secondaryBus;
|
||||
|
||||
baseClass = getBaseClass(bus, device, function);
|
||||
subClass = getSubClass (bus, device, function );
|
||||
if ( (baseClass == 0x06) && (subClass == 0x04)){
|
||||
secondaryBus = getSecondaryBus(bus,device, function);
|
||||
checkBus(secondaryBus);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ConfigReadWord (uint8_t bus, uint8_t device, uint8_t func, uint8_t offset){
|
||||
uint32_t 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);
|
||||
|
||||
|
||||
return inl(CONFIG_DATA);
|
||||
}
|
||||
|
||||
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!
|
||||
}
|
||||
|
||||
uint16_t GetClassCodes( PCIBusAddress& PCIDeviceAddress ){
|
||||
uint32_t classcodes = ConfigReadWord(PCIDeviceAddress, 0x8);
|
||||
return (uint16_t)((uint32_t)classcodes >> 16);
|
||||
|
||||
}
|
||||
|
||||
bool IsMultiFunctionDevice(PCIBusAddress& PCIDeviceAddress){
|
||||
uint32_t header_information = ConfigReadWord(PCIDeviceAddress, 0xC);
|
||||
return (((header_information>>16)
|
||||
& 0x80)
|
||||
>> 7 );
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
//uint64_t DeviceIdentify = ConfigReadWord(bus, device, function,0x0);
|
||||
uint32_t DeviceID = GetDevice(bus, device, function) >> 16;
|
||||
|
||||
|
||||
|
||||
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++;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
printf("Found %d PCI devices!\n", devicesFound);
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t GetProgIF (PCIBusAddress& PCIDeviceAddress){
|
||||
uint32_t data = ConfigReadWord(PCIDeviceAddress, 0x8);
|
||||
return ((data >> 8) & 0xFF);
|
||||
// Recursive scan
|
||||
void checkBus (uint8_t bus){
|
||||
uint8_t device;
|
||||
|
||||
for(device = 0; device < 32; device ++){
|
||||
checkDevice(bus,device);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ReadBAR ( PCIBusAddress& PCIDeviceAddress, int bar_number){
|
||||
int offsetToBar = 0x10 + (bar_number* 0x4);
|
||||
return ConfigReadWord(PCIDeviceAddress, offsetToBar);
|
||||
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;
|
||||
}
|
||||
bus = function;
|
||||
checkBus(bus);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,38 +1,58 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include "io.h"
|
||||
#include "tty/kterm.h"
|
||||
#include "pci/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
|
||||
|
||||
extern const char* ClassCodeTable [0x13];
|
||||
/*
|
||||
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
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
PCI Device structure
|
||||
|
||||
// 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));
|
||||
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
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
uint8_t GetHeaderType( PCIBusAddress& PCIDeviceAddress );
|
||||
/*
|
||||
The idea for now is to support the minimal things necessary to find ATA supported drives
|
||||
*/
|
||||
|
||||
uint16_t GetClassCodes( PCIBusAddress& PICDeviceAddress );
|
||||
const char* getVendor( uint64_t VendorID);
|
||||
const char* GetClassCodeName (uint64_t ClassCode );
|
||||
|
||||
uint8_t GetProgIF (PCIBusAddress& PCIDeviceAddress);
|
||||
void PCI_Enumerate();
|
||||
// Lets write some boiler plate configuration code
|
||||
|
||||
uint32_t ReadBAR ( PCIBusAddress& PCIDeviceAddress, int bar_number);
|
||||
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 );
|
||||
@ -1,7 +0,0 @@
|
||||
#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};
|
||||
}
|
||||
@ -1,54 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
/*
|
||||
* 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;
|
||||
|
||||
};
|
||||
@ -1,9 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
#include "tty/kterm.h"
|
||||
#include "io.h"
|
||||
|
||||
#define PORT 0x3f8
|
||||
static int init_serial() {
|
||||
|
||||
inline static int init_serial() {
|
||||
outb(PORT + 1, 0x00); // Disable all interrupts
|
||||
outb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
|
||||
outb(PORT + 0, 0x03); // Set divisor to 3 (lo byte) 38400 baud
|
||||
@ -25,33 +26,95 @@ 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]);
|
||||
}
|
||||
}
|
||||
|
||||
void test_serial(){
|
||||
|
||||
inline void printf_serial ( const char *format, ...) {
|
||||
|
||||
char **arg = (char **)&format;
|
||||
int c;
|
||||
char buf[20];
|
||||
|
||||
arg++;
|
||||
|
||||
while ((c = *format++) != 0){
|
||||
if( c != '%')
|
||||
write_serial(c);
|
||||
else{
|
||||
char *p, *p2;
|
||||
int pad0 = 0, pad = 0;
|
||||
|
||||
c = *format++;
|
||||
if(c =='0'){
|
||||
pad0 = 1;
|
||||
c = *format++;
|
||||
}
|
||||
|
||||
if ( c >= '0' && c <= '9'){
|
||||
pad = c - '0';
|
||||
c = *format++;
|
||||
}
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case 'd':
|
||||
|
||||
case 'u':
|
||||
case 'x':
|
||||
itoa(buf, c, *((int *) arg++));
|
||||
|
||||
p = buf;
|
||||
goto string;
|
||||
break;
|
||||
|
||||
case 's':
|
||||
p = *arg++;
|
||||
if(!p)
|
||||
p = "(null)";
|
||||
|
||||
string:
|
||||
for (p2 = p; *p2; p2++);
|
||||
for (; p2 < p + pad; p2++)
|
||||
write_serial(pad0 ? '0': ' ');
|
||||
while (*p)
|
||||
write_serial(*p++);
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
write_serial(*((int *)arg++));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void test_serial(){
|
||||
/** Serial test **/
|
||||
kterm_writestring("Writing to COM1 serial port:");
|
||||
init_serial();
|
||||
|
||||
@ -137,7 +137,7 @@ void kterm_writestring(const char* data ){
|
||||
}
|
||||
|
||||
|
||||
static void itoa (char *buf, int base, int d) {
|
||||
void itoa (char *buf, int base, int d) {
|
||||
char *p = buf;
|
||||
char *p1, *p2;
|
||||
unsigned long ud = d;
|
||||
@ -174,7 +174,7 @@ static void itoa (char *buf, int base, int d) {
|
||||
}
|
||||
|
||||
void printf ( const char *format, ...) {
|
||||
|
||||
return;
|
||||
char **arg = (char **)&format;
|
||||
int c;
|
||||
char buf[20];
|
||||
|
||||
@ -33,10 +33,9 @@ uint16_t get_cursor_position();
|
||||
int get_cursor_x (uint16_t cursor_pos);
|
||||
int get_cursor_y (uint16_t cursor_pos);
|
||||
|
||||
|
||||
extern "C" void itoa (char *buf, int base, int d);
|
||||
void printf ( const char *format, ...);
|
||||
|
||||
//static void itoa (char *buf, int base, int d);
|
||||
|
||||
#define KernelTag "[Kernel]: "
|
||||
#define AS_KERNEL() ( kterm_setcolor(VGA_COLOR_LIGHT_BLUE),\
|
||||
|
||||
Reference in New Issue
Block a user