1 files changed, 80 insertions, 252 deletions

diff --git a/src/kernel/fs/ata.c b/src/kernel/fs/ata.c
index b637dbd..d5c758c 100644
--- a/src/kernel/fs/ata.c
+++ b/src/kernel/fs/ata.c
@@ -1,292 +1,120 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <kernel/fs/ata.h>
 #include <kernel/system.h>
 #include <kernel/io/io.h>
-#include <kernel/fs/ata.h>
-#include <kernel/lib/lib.h>
-#include <kernel/lib/stdlib.h>
-#include <kernel/lib/stdio.h>
-#include <kernel/memory/alloc.h>
-#include <kernel/pci/pci.h>
-#include <kernel/interrupts/interrupts.h>
 
-uint32_t ata_device = 0x00000000;
+static uint16_t sel_base_port = 0;
+static uint8_t sel_master_or_slave = 0;
 
-ata_dev_t primary_master = { .slave = 0 };
-ata_dev_t primary_slave = { .slave = 1 };
-ata_dev_t secondary_master = { .slave = 0 };
-ata_dev_t secondary_slave = { .slave = 1 };
-
-void io_wait(ata_dev_t *dev)
-{
-	inb(dev->alt_status);
-	inb(dev->alt_status);
-	inb(dev->alt_status);
-	inb(dev->alt_status);
-}
+static uint32_t max_sector;
 
-void software_reset(ata_dev_t *dev)
+static uint8_t read_stat(uint16_t base)
 {
-	outb(dev->control, CONTROL_SOFTWARE_RESET);
-	io_wait(dev);
-	outb(dev->control, CONTROL_ZERO);
-}
+	inb(base + COM_STAT);
+	inb(base + COM_STAT);
+	inb(base + COM_STAT);
+	inb(base + COM_STAT);
 
-void ata_handler(struct regs *r)
-{
-	inb(primary_master.status);
-	inb(primary_master.BMR_STATUS);
-	outb(primary_master.BMR_COMMAND, BMR_COMMAND_DMA_STOP);
-	//irq_ack(14);
+	return inb(base + COM_STAT);
 }
 
-void ata_open(vfs_node_t *node, uint32_t flags)
+static void check_drive(uint16_t base, uint8_t master_or_slave)
 {
-	return;
-}
+	if (sel_base_port != 0)
+		return;
 
-void ata_close(vfs_node_t *node)
-{
-	return;
-}
+	outb(base + DRIVE_SELECT, master_or_slave);
 
-uint32_t ata_read(vfs_node_t *node, uint32_t offset, uint32_t size, char *buf)
-{
-	uint32_t start = offset / SECTOR_SIZE;
-	uint32_t start_offset = offset % SECTOR_SIZE;
+	outb(base + SECTOR_COUNT, 0);
+	outb(base + LBA_LOW, 0);
+	outb(base + LBA_MID, 0);
+	outb(base + LBA_HIGH, 0);
 
-	uint32_t end = (offset + size - 1) / SECTOR_SIZE;
-	uint32_t end_offset = (offset + size - 1) % SECTOR_SIZE;
+	outb(base + COM_STAT, IDENTIFY);
+	uint8_t stat = read_stat(base);
 
-	char *buf_curr = buf;
-	uint32_t counter = start;
-	uint32_t read_size;
-	uint32_t off, total = 0;
-
-	while (counter <= end) {
-		off = 0;
-		read_size = SECTOR_SIZE;
+	if (stat == 0)
+		return;
 
-		char *ret = ata_read_sector((ata_dev_t *)node->device, counter);
+	while ((stat & BSY) != 0)
+		stat = read_stat(base);
 
-		if (counter == start) {
-			off = start_offset;
-			read_size = SECTOR_SIZE - off;
-		}
-		if (counter == end)
-			read_size = end_offset - off + 1;
+	while ((stat & DRQ) == 0 && (stat & ERR) == 0)
+		stat = read_stat(base);
 
-		memcpy(buf_curr, ret + off, read_size);
-		buf_curr = buf_curr + read_size;
-		total = total + read_size;
-		counter++;
-	}
-	return total;
-}
-
-uint32_t ata_write(vfs_node_t *node, uint32_t offset, uint32_t size, char *buf)
-{
-	uint32_t start = offset / SECTOR_SIZE;
-	uint32_t start_offset = offset % SECTOR_SIZE;
+	if ((stat & ERR) != 0)
+		return;
 
-	uint32_t end = (offset + size - 1) / SECTOR_SIZE;
-	uint32_t end_offset = (offset + size - 1) % SECTOR_SIZE;
+	uint16_t drive_data[256];
+	for (size_t i = 0; i < 256; i++)
+		drive_data[i] = inw(base + DATA);
 
-	char *buf_curr = buf;
-	uint32_t counter = start;
-	uint32_t write_size;
-	uint32_t off, total = 0;
+	max_sector = drive_data[MAX_28LBA_SECTORS] | drive_data[MAX_28LBA_SECTORS + 1] << 16;
 
-	while (counter <= end) {
-		off = 0;
-		write_size = SECTOR_SIZE;
-		char *ret = ata_read_sector((ata_dev_t *)node->device, counter);
-		if (counter == start) {
-			off = start_offset;
-			write_size = SECTOR_SIZE - off;
-		}
-		if (counter == end) {
-			write_size = end_offset - off + 1;
-		}
-		memcpy(ret + off, buf_curr, write_size);
-		ata_write_sector((ata_dev_t *)node->device, counter, ret);
-		buf_curr = buf_curr + write_size;
-		total = total + write_size;
-		counter++;
-	}
-	return total;
+	sel_base_port = base;
+	sel_master_or_slave = master_or_slave;
 }
 
-void ata_write_sector(ata_dev_t *dev, uint32_t lba, char *buf)
+void ata_init()
 {
-	memcpy(dev->mem_buffer, buf, SECTOR_SIZE);
-
-	outb(dev->BMR_COMMAND, 0);
-	outl(dev->BMR_prdt, (uint32_t)dev->prdt_phys);
-	outb(dev->drive, 0xe0 | dev->slave << 4 | (lba & 0x0f000000) >> 24);
-	outb(dev->sector_count, 1);
-	outb(dev->lba_lo, lba & 0x000000ff);
-	outb(dev->lba_mid, (lba & 0x0000ff00) >> 8);
-	outb(dev->lba_high, (lba & 0x00ff0000) >> 16);
-
-	outb(dev->command, 0xCA);
-
-	outb(dev->BMR_COMMAND, 0x1);
-
-	while (1) {
-		int status = inb(dev->BMR_STATUS);
-		int dstatus = inb(dev->status);
-		if (!(status & 0x04)) {
-			continue;
-		}
-		if (!(dstatus & 0x80)) {
-			break;
-		}
+	uint8_t pri_status = inb(PRIMARY_BASE + COM_STAT);
+	uint8_t sec_status = inb(SECONDARY_BASE + COM_STAT);
+	bool primary_floating = false;
+	bool secondary_floating = false;
+	if (pri_status == 0xFF)
+		primary_floating = true;
+	if (sec_status == 0xFF)
+		secondary_floating = true;
+
+	if (primary_floating && secondary_floating) {
+		log("No drives attached! What's going on?");
+		return;
 	}
-}
-
-char *ata_read_sector(ata_dev_t *dev, uint32_t lba)
-{
-	char *buf = kmalloc(SECTOR_SIZE);
 
-	outb(dev->BMR_COMMAND, 0);
-	outl(dev->BMR_prdt, (uint32_t)dev->prdt_phys);
-	outb(dev->drive, 0xe0 | dev->slave << 4 | (lba & 0x0f000000) >> 24);
-	outb(dev->sector_count, 1);
-	outb(dev->lba_lo, lba & 0x000000ff);
-	outb(dev->lba_mid, (lba & 0x0000ff00) >> 8);
-	outb(dev->lba_high, (lba & 0x00ff0000) >> 16);
-
-	outb(dev->command, 0xC8);
-
-	outb(dev->BMR_COMMAND, 0x8 | 0x1);
-
-	while (1) {
-		int status = inb(dev->BMR_STATUS);
-		int dstatus = inb(dev->status);
-		if (!(status & 0x04)) {
-			continue;
-		}
-		if (!(dstatus & 0x80)) {
-			break;
-		}
+	check_drive(PRIMARY_BASE, SEL_MASTER);
+	check_drive(PRIMARY_BASE, SEL_SLAVE);
+	check_drive(SECONDARY_BASE, SEL_MASTER);
+	check_drive(SECONDARY_BASE, SEL_SLAVE);
+
+	if (sel_base_port == 0)
+		log("No drives attached! What's going on?");
+	else {
+		log("Found a drive!\nSelected drive is the %s on the %s bus",
+		    sel_master_or_slave == SEL_MASTER ? "master" : "slave",
+		    sel_base_port == PRIMARY_BASE ? "primary" : "secondary");
+		log("Max LBA value is %d", max_sector);
 	}
-
-	memcpy(buf, dev->mem_buffer, SECTOR_SIZE);
-	return buf;
 }
 
-vfs_node_t *create_ata_device(ata_dev_t *dev)
+static void poll()
 {
-	vfs_node_t *t = kcalloc(sizeof(vfs_node_t), 1);
-	strcpy(t->name, "ata device ");
-	t->name[strlen(t->name)] = dev->mountpoint[strlen(dev->mountpoint) - 1];
-	t->device = dev;
-	t->flags = FS_BLOCKDEVICE;
-	t->read = ata_read;
-	t->write = ata_write;
-	t->open = ata_open;
-	t->close = ata_close;
-	return t;
-}
-
-void ata_device_init(ata_dev_t *dev, int primary)
-{
-	dev->prdt = (void *)kmalloc(sizeof(prdt_t));
-	memset(dev->prdt, 0, sizeof(prdt_t));
-	dev->prdt_phys = (uint8_t *)paging_get_phys((uint32_t)dev->prdt);
-	dev->mem_buffer = (void *)kmalloc(4096);
-	memset(dev->mem_buffer, 0, 4096);
-
-	dev->prdt[0].buffer_phys = (uint32_t)paging_get_phys((uint32_t)dev->mem_buffer);
-	dev->prdt[0].transfer_size = SECTOR_SIZE;
-	dev->prdt[0].mark_end = MARK_END;
+	uint8_t stat;
 
-	uint16_t base_addr = primary ? (0x1F0) : (0x170);
-	uint16_t alt_status = primary ? (0x3F6) : (0x376);
-
-	dev->data = base_addr;
-	dev->error = base_addr + 1;
-	dev->sector_count = base_addr + 2;
-	dev->lba_lo = base_addr + 3;
-	dev->lba_mid = base_addr + 4;
-	dev->lba_high = base_addr + 5;
-	dev->drive = base_addr + 6;
-	dev->command = base_addr + 7;
-	dev->alt_status = alt_status;
-
-	dev->bar4 = pci_read_field(ata_device, PCI_BAR4, 4);
-	if (dev->bar4 & 0x1) {
-		dev->bar4 = dev->bar4 & 0xfffffffc;
-	}
-	dev->BMR_COMMAND = dev->bar4;
-	dev->BMR_STATUS = dev->bar4 + 2;
-	dev->BMR_prdt = dev->bar4 + 4;
-
-	memset(dev->mountpoint, 0, 32);
-	strcpy(dev->mountpoint, "/dev/hd");
-	dev->mountpoint[strlen(dev->mountpoint)] = 'a' + (((!primary) << 1) | dev->slave);
+	do
+		stat = read_stat(sel_base_port);
+	while ((stat & BSY) != 0);
 }
 
-void ata_device_detect(ata_dev_t *dev, int primary)
+void read_abs_sectors(uint32_t lba, uint8_t sector_count, uint16_t buf[])
 {
-	ata_device_init(dev, primary);
+	assert(lba >> LBA_BITS == 0);
 
-	software_reset(dev);
-	io_wait(dev);
-	outb(dev->drive, (0xA + dev->slave) << 4);
-	outb(dev->sector_count, 0);
-	outb(dev->lba_lo, 0);
-	outb(dev->lba_mid, 0);
-	outb(dev->lba_high, 0);
+	outb(sel_base_port + DRIVE_SELECT, (lba >> (LBA_BITS - 4)) | sel_master_or_slave | 1 << 6);
+	outb(sel_base_port + SECTOR_COUNT, sector_count);
 
-	outb(dev->command, COMMAND_IDENTIFY);
-	if (!inb(dev->status)) {
-		warn("Device does not exist: %s", dev->mountpoint);
-		return;
-	}
+	outb(sel_base_port + LBA_LOW, lba & 0xFF);
+	outb(sel_base_port + LBA_MID, (lba >> 8) & 0xFF);
+	outb(sel_base_port + LBA_HIGH, (lba >> 16) & 0xFF);
 
-	uint8_t lba_lo = inb(dev->lba_lo);
-	uint8_t lba_hi = inb(dev->lba_high);
-	if (lba_lo != 0 || lba_hi != 0) {
-		warn("Device is not ata-compatible: %s", dev->mountpoint);
-		return;
-	}
-	uint8_t drq = 0, err = 0;
-	while (!drq && !err) {
-		drq = inb(dev->status) & STATUS_DRQ;
-		err = inb(dev->status) & STATUS_ERR;
-	}
-	if (err) {
-		warn("Error while polling: %s", dev->mountpoint);
-		return;
-	}
+	outb(sel_base_port + COM_STAT, READ_SECTORS);
 
-	for (int i = 0; i < 256; i++)
-		inw(dev->data);
+	size_t i = 0;
+	for (; sector_count > 0; sector_count--) {
+		poll();
 
-	uint32_t pci_command_reg = pci_read_field(ata_device, PCI_COMMAND, 2);
-	if (!(pci_command_reg & (1 << 2))) {
-		pci_command_reg |= (1 << 2);
-		pci_write_field(ata_device, PCI_COMMAND, pci_command_reg);
+		asm("rep insw" ::"c"(SECTOR_SIZE / 2), "d"(sel_base_port + DATA), "D"(buf + i));
+		i += SECTOR_SIZE / 2;
 	}
-
-	log("Detected drive: %s", dev->mountpoint);
-	vfs_mount(dev->mountpoint, create_ata_device(dev));
-}
-
-void ata_find(uint32_t device, uint16_t vendor_id, uint16_t device_id, void *extra)
-{
-	if ((vendor_id == ATA_VENDOR_ID) && (device_id == ATA_DEVICE_ID))
-		*((uint32_t *)extra) = device;
-}
-
-void ata_init()
-{
-	pci_scan(&ata_find, -1, &ata_device);
-
-	irq_install_handler(14, ata_handler);
-
-	ata_device_detect(&primary_master, 1);
-	ata_device_detect(&primary_slave, 1);
-	// ata_device_detect(&secondary_master, 0);
-	// ata_device_detect(&secondary_slave, 0);
 }
\ No newline at end of file