From 41874c455c755f00ca73c2e2ee5ab8c4b0dbe61e Mon Sep 17 00:00:00 2001 From: Alexis211 Date: Sun, 29 Nov 2009 16:22:01 +0100 Subject: Reading from HDD is now possible ! --- Source/Kernel/Core/Sys.ns.cpp | 4 ++ Source/Kernel/Core/Sys.ns.h | 1 + Source/Kernel/Core/kmain.wtf.cpp | 2 + Source/Kernel/Devices/ATA/ATAController.class.cpp | 53 +++++++++++++++++ Source/Kernel/Devices/ATA/ATAController.class.h | 47 +++++++++++++++ Source/Kernel/Devices/ATA/ATADrive.class.cpp | 71 +++++++++++++++++++++++ Source/Kernel/Devices/ATA/ATADrive.class.h | 30 ++++++++++ Source/Kernel/Makefile | 2 + Source/Kernel/VFS/Part.ns.cpp | 25 ++++++-- Source/Kernel/VFS/Part.ns.h | 13 +++++ Source/Kernel/VFS/Partition.class.cpp | 4 +- 11 files changed, 244 insertions(+), 8 deletions(-) create mode 100644 Source/Kernel/Devices/ATA/ATAController.class.cpp create mode 100644 Source/Kernel/Devices/ATA/ATAController.class.h create mode 100644 Source/Kernel/Devices/ATA/ATADrive.class.cpp create mode 100644 Source/Kernel/Devices/ATA/ATADrive.class.h diff --git a/Source/Kernel/Core/Sys.ns.cpp b/Source/Kernel/Core/Sys.ns.cpp index 49b2725..c5af3e8 100644 --- a/Source/Kernel/Core/Sys.ns.cpp +++ b/Source/Kernel/Core/Sys.ns.cpp @@ -18,6 +18,10 @@ void outb (u16int port, u8int value) { asm volatile ("outb %1, %0" : : "dN" (port), "a" (value)); } +void outw (u16int port, u16int value) { + asm volatile ("outw %1, %0" : : "dN" (port), "a" (value)); +} + u8int inb (u16int port) { u8int ret; asm volatile ("inb %1, %0" : "=a" (ret) : "dN" (port)); diff --git a/Source/Kernel/Core/Sys.ns.h b/Source/Kernel/Core/Sys.ns.h index 9b34dbf..26f04e6 100644 --- a/Source/Kernel/Core/Sys.ns.h +++ b/Source/Kernel/Core/Sys.ns.h @@ -26,6 +26,7 @@ extern SimpleVT* kvt; namespace Sys { void outb(u16int port, u8int value); + void outw(u16int port, u8int value); u8int inb(u16int port); u16int inw(u16int port); void dumpRegs(registers_t *regs, VirtualTerminal& vt); diff --git a/Source/Kernel/Core/kmain.wtf.cpp b/Source/Kernel/Core/kmain.wtf.cpp index a028457..3eee14b 100644 --- a/Source/Kernel/Core/kmain.wtf.cpp +++ b/Source/Kernel/Core/kmain.wtf.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -186,6 +187,7 @@ void kmain(multiboot_info_t* mbd, u32int magic) { Kbd::setFocus(kvt); //Set focus to virtual terminal if (enableVESA) Dev::registerDevice(new VESADisplay()); FloppyController::detect(); + ATAController::detect(); //*************************************** MOUNT FILESYSTEMS diff --git a/Source/Kernel/Devices/ATA/ATAController.class.cpp b/Source/Kernel/Devices/ATA/ATAController.class.cpp new file mode 100644 index 0000000..69a18a4 --- /dev/null +++ b/Source/Kernel/Devices/ATA/ATAController.class.cpp @@ -0,0 +1,53 @@ +#include "ATADrive.class.h" + +#include +#include + +String ATAController::getClass() { + return "controller.ata"; +} + +String ATAController::getName() { + return String("ATA controller #") + String::number(m_number); +} + +void ATAController::detect() { + ATAController *c[2]; + c[0] = new ATAController(ATA_BUS1_BASE, 0); + c[1] = new ATAController(ATA_BUS2_BASE, 1); + Dev::registerDevice(c[0]); Dev::registerDevice(c[1]); + for (u32int d = 0; d < 2; d++) { + for (u32int r = 0; r < 2; r++) { + ATADrive* drv = c[d]->m_drives[r]; + if (drv != 0) { + Dev::registerDevice(drv); + Part::registerDevice(drv); + } + } + } +} + +ATAController::ATAController(u32int base, u8int number) { + m_base = base; m_number = number; + m_drives[0] = NULL; m_drives[1] = NULL; + identify(false); //Identify master device + identify(true); //Identify slave device +} + +void ATAController::identify(bool slave) { + if (m_drives[(slave ? 1 : 0)] != NULL) return; + writeByte(ATA_PORT_DRIVE_SELECT, (slave ? 0xB0 : 0xA0)); + writeByte(ATA_PORT_COMMAND, ATA_CMD_IDENTIFY); + u8int ret = readByte(ATA_PORT_COMMAND); + if (ret == 0) return; //Drive does not exist + while ((ret & 0x88) != 0x08 and (ret & 1) != 1) { + ret = readByte(ATA_PORT_COMMAND); + } + if ((ret & 1) == 1) return; //Error while IDENTIFY + u16int data[256]; + for (u32int i = 0; i < 256; i++) data[i] = readWord(ATA_PORT_DATA); + u32int blocks = (data[61] << 16) | data[60]; + if (blocks != 0) { //Drive supports LBA28 + m_drives[(slave ? 1 : 0)] = new ATADrive(this, slave, blocks, data); + } +} diff --git a/Source/Kernel/Devices/ATA/ATAController.class.h b/Source/Kernel/Devices/ATA/ATAController.class.h new file mode 100644 index 0000000..a12b835 --- /dev/null +++ b/Source/Kernel/Devices/ATA/ATAController.class.h @@ -0,0 +1,47 @@ +#ifndef DEF_ATACONTROLLER_CLASS_H +#define DEF_ATACONTROLLER_CLASS_H + +#include + +#define ATA_BUS1_BASE 0x1F0 +#define ATA_BUS2_BASE 0x170 + +#define ATA_PORT_DATA 0 +#define ATA_PORT_FEATURES_ERROR 1 +#define ATA_PORT_SECT_COUNT 2 +#define ATA_PORT_PARTIAL1 3 +#define ATA_PORT_PARTIAL2 4 +#define ATA_PORT_PARTIAL3 5 +#define ATA_PORT_DRIVE_SELECT 6 +#define ATA_PORT_COMMAND 7 + +#define ATA_CMD_IDENTIFY 0xEC +#define ATA_CMD_READ 0x20 +#define ATA_CMD_WRITE 0x30 + +class ATADrive; + +class ATAController : public Device { + friend class ATADrive; + private: + ATAController(u32int base, u8int number); + + u32int m_base; + u8int m_number; + + ATADrive* m_drives[2]; + + void writeWord(u16int port, u16int word) { Sys::outw(m_base + port, word); } + void writeByte(u16int port, u8int byte) { Sys::outb(m_base + port, byte); } + u8int readByte(u16int port) { return Sys::inb(m_base + port); } + u16int readWord(u16int port) { return Sys::inw(m_base + port); } + + void identify(bool slave); //Identifies a drive and adds it to m_drives + + public: + static void detect(); + String getClass(); + String getName(); +}; + +#endif diff --git a/Source/Kernel/Devices/ATA/ATADrive.class.cpp b/Source/Kernel/Devices/ATA/ATADrive.class.cpp new file mode 100644 index 0000000..d9cc4a7 --- /dev/null +++ b/Source/Kernel/Devices/ATA/ATADrive.class.cpp @@ -0,0 +1,71 @@ +#include "ATADrive.class.h" + +String ATADrive::getClass() { + return "block.ata"; +} + +String ATADrive::getName() { + return String("ATA drive ") += String::number(m_ctrlr->m_number) += String(m_isSlave ? ".slave " : ".master ") + += String::number(m_blockCount / (1024 * 1024 / blockSize())) += "MB"; +} + +ATADrive::ATADrive(ATAController* ctrlr, bool isSlave, u32int blockCount, u16int* identifyData) { + m_ctrlr = ctrlr; + m_isSlave = isSlave; + m_blockCount = blockCount; + for (u32int i = 0; i < 256; i++) m_identifyData[i] = identifyData[i]; +} + +bool ATADrive::readOnly() { + return true; +} + +u64int ATADrive::blocks() { + return m_blockCount; +} + +void ATADrive::cmdCommon(u32int numblock, u32int count) { + m_ctrlr->writeByte(ATA_PORT_FEATURES_ERROR, 0); + m_ctrlr->writeByte(ATA_PORT_SECT_COUNT, count); + m_ctrlr->writeByte(ATA_PORT_PARTIAL1, numblock); + m_ctrlr->writeByte(ATA_PORT_PARTIAL2, numblock >> 8); + m_ctrlr->writeByte(ATA_PORT_PARTIAL3, numblock >> 16); + + m_ctrlr->writeByte(ATA_PORT_DRIVE_SELECT, 0xE0 | (m_isSlave ? 0x10 : 0) | ((numblock >> 24) & 0x0F)); +} + +bool ATADrive::readBlocks(u64int start, u32int count, u8int* data) { + if (start + count >= m_blockCount) return false; + + cmdCommon(start, count); + m_ctrlr->writeByte(ATA_PORT_COMMAND, ATA_CMD_READ); + + while (!(m_ctrlr->readByte(ATA_PORT_COMMAND) & 0x08)); //Wait for the drive to be ready + + for (u32int idx = 0; idx < count * 256; idx++) { + u16int tmpword = m_ctrlr->readWord(ATA_PORT_DATA); + data[idx * 2] = (u8int)tmpword; + data[idx * 2 + 1] = (u8int)(tmpword >> 8); + } + return true; +} + +bool ATADrive::writeBlocks(u64int start, u32int count, u8int* data) { + if (start + count >= m_blockCount) return false; + if (readOnly()) return false; + + cmdCommon(start, count); + m_ctrlr->writeByte(ATA_PORT_COMMAND, ATA_CMD_WRITE); + + while (!(m_ctrlr->readByte(ATA_PORT_COMMAND) & 0x08)); //Wait for the drive to be ready + + for (u32int idx = 0; idx < count * 256; idx++) { + u16int tmpword = (data[idx * 2]) | (data[idx * 2 + 1] << 8); + m_ctrlr->writeByte(ATA_PORT_DATA, tmpword); + } + return true; +} + +u32int ATADrive::blockSize() { + return 512; +} diff --git a/Source/Kernel/Devices/ATA/ATADrive.class.h b/Source/Kernel/Devices/ATA/ATADrive.class.h new file mode 100644 index 0000000..b6087bf --- /dev/null +++ b/Source/Kernel/Devices/ATA/ATADrive.class.h @@ -0,0 +1,30 @@ +#ifndef DEF_ATADRIVE_CLASS_H +#define DEF_ATADRIVE_CLASS_H + +#include "ATAController.class.h" +#include + +class ATADrive : public BlockDevice { + friend class ATAController; + private: + ATADrive(ATAController* ctrlr, bool isSlave, u32int blockCount, u16int* identifyData); + + ATAController* m_ctrlr; + bool m_isSlave; + u32int m_blockCount; + u16int m_identifyData[256]; + + void cmdCommon(u32int numblock, u32int count); + + public: + String getClass(); + String getName(); + + bool readOnly(); + u64int blocks(); + bool readBlocks(u64int start, u32int count, u8int* data); + bool writeBlocks(u64int start, u32int count, u8int* data); + u32int blockSize(); +}; + +#endif diff --git a/Source/Kernel/Makefile b/Source/Kernel/Makefile index 2005cd2..660017a 100644 --- a/Source/Kernel/Makefile +++ b/Source/Kernel/Makefile @@ -77,6 +77,8 @@ Objects = Core/loader.wtf.o \ Devices/Keyboard/PS2Keyboard.class.o \ Devices/Floppy/FloppyController.class.o \ Devices/Floppy/FloppyDrive.class.o \ + Devices/ATA/ATAController.class.o \ + Devices/ATA/ATADrive.class.o \ Devices/Timer.class.o all: $(OutFile) diff --git a/Source/Kernel/VFS/Part.ns.cpp b/Source/Kernel/VFS/Part.ns.cpp index 9ead6b5..415a150 100644 --- a/Source/Kernel/VFS/Part.ns.cpp +++ b/Source/Kernel/VFS/Part.ns.cpp @@ -1,5 +1,7 @@ #include "Part.ns.h" +#include + namespace Part { Vector devices; @@ -7,6 +9,21 @@ Vector partitions; void readPartitionTable(BlockDevice *dev) { //TODO : read partition table from device partitions.push(new Partition(dev, 0, 0, dev->blocks())); //Insert whole device as a partition + + u8int* mbr = (u8int*)Mem::alloc(dev->blockSize()); + if (!dev->readBlocks(0, 1, mbr)) return; + + mbr_entry_t* entries = (mbr_entry_t*)((u32int)mbr + 0x1BE); + + for (u32int i = 0; i < 4; i++) { + if ((entries[i].bootable == 0 or entries[i].bootable == 0x80) and entries[i].id != 0 + and entries[i].s_lba != 0 and entries[i].size != 0 + and entries[i].s_lba < dev->blocks() and entries[i].size < dev->blocks()) { + partitions.push(new Partition(dev, i + 1, entries[i].s_lba, entries[i].size)); + } + } + + Mem::free(mbr); } void registerDevice(BlockDevice *dev) { @@ -73,12 +90,8 @@ BlockDevice* dev(String _class, u32int idx) { Partition* part(BlockDevice* dev, u32int idx) { for (u32int i = 0; i < partitions.size(); i++) { - if (partitions[i]->getDevice() == dev) { - if (idx == 0) { - return partitions[i]; - } else { - idx--; - } + if (partitions[i]->getDevice() == dev && partitions[i]->getPartNumber() == idx) { + return partitions[i]; } } return NULL; diff --git a/Source/Kernel/VFS/Part.ns.h b/Source/Kernel/VFS/Part.ns.h index 992f6f3..e6a358c 100644 --- a/Source/Kernel/VFS/Part.ns.h +++ b/Source/Kernel/VFS/Part.ns.h @@ -6,6 +6,19 @@ #include namespace Part { + struct mbr_entry_t { + u8int bootable; /* 0 = no, 0x80 = bootable */ + u8int s_head; /* Starting head */ + u16int s_sector : 6; /* Starting sector */ + u16int s_cyl : 10; /* Starting cylinder */ + u8int id; /* System ID */ + u8int e_head; /* Ending head */ + u16int e_sector : 6; /* Ending sector */ + u16int e_cyl : 10; /* Ending cylinder */ + u32int s_lba; /* Starting sector (LBA value) */ + u32int size; /* Total sector number */ + } __attribute__ ((packed)); + extern Vector devices; extern Vector partitions; diff --git a/Source/Kernel/VFS/Partition.class.cpp b/Source/Kernel/VFS/Partition.class.cpp index 8d7de9b..9da3461 100644 --- a/Source/Kernel/VFS/Partition.class.cpp +++ b/Source/Kernel/VFS/Partition.class.cpp @@ -13,12 +13,12 @@ Partition::Partition(BlockDevice* dev, u8int partnumber, u64int startblock, u64i bool Partition::readBlocks(u64int startblock, u32int count, u8int *data) { if (startblock + count > m_startblock + m_blockcount) return false; - return m_cache.readBlocks(startblock - m_startblock, count, data); + return m_cache.readBlocks(startblock + m_startblock, count, data); } bool Partition::writeBlocks(u64int startblock, u32int count, u8int *data) { if (startblock + count > m_startblock + m_blockcount) return false; - return m_cache.writeBlocks(startblock - m_startblock, count, data); + return m_cache.writeBlocks(startblock + m_startblock, count, data); } bool Partition::read(u64int start, u32int length, u8int *data) { -- cgit v1.2.3