Kernel: Rewrite basically all current disk io stuff

This is a big commit that was kinda hard to split to smaller ones.

Essentially we now look at all the mass storage devices from PCI
and initialize (P)ATA devices. This doesn't provide any more functionality
but better abstractions and everything doesn't have to be on its old
default port that might be different for modern computers.

kernel/include/kernel/Storage/ATAController.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <BAN/Errors.h>
+#include <kernel/Storage/StorageController.h>
+
+namespace Kernel
+{
+
+	struct ATABus;
+
+	class ATADevice : public StorageDevice
+	{
+	public:
+		virtual BAN::ErrorOr<void> read_sectors(uint64_t, uint8_t, uint8_t*) override;
+		virtual uint32_t sector_size() const override { return sector_words * 2; }
+		virtual uint64_t total_size() const override { return lba_count * sector_size(); }
+
+	private:
+		enum class Type
+		{
+			Unknown,
+			ATA,
+			ATAPI,
+		};
+
+		Type type;
+		uint8_t slave_bit; // 0x00 for master, 0x10 for slave
+		uint16_t signature;
+		uint16_t capabilities;
+		uint32_t command_set;
+		uint32_t sector_words;
+		uint64_t lba_count;
+		char model[41];
+
+		ATABus* bus;
+
+		friend class ATAController;
+	};
+
+	struct ATABus
+	{
+		uint16_t base;
+		uint16_t ctrl;
+		ATADevice devices[2];
+
+		uint8_t read(uint16_t);
+		void read_buffer(uint16_t, uint16_t*, size_t);
+		void write(uint16_t, uint8_t);
+		BAN::ErrorOr<void> wait(bool);
+		BAN::Error error();
+	};
+
+	class ATAController : public StorageController
+	{
+	public:
+		static BAN::ErrorOr<ATAController*> create(const PCIDevice&);
+
+	private:
+		ATAController(const PCIDevice& device) : m_pci_device(device) {}
+		BAN::ErrorOr<void> initialize();
+
+	private:
+		ATABus m_buses[2];
+		const PCIDevice& m_pci_device;
+	};
+
+}

kernel/include/kernel/Storage/StorageController.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <kernel/PCI.h>
+#include <kernel/Storage/StorageDevice.h>
+
+namespace Kernel
+{
+
+	class StorageController
+	{
+	public:
+		BAN::Vector<StorageDevice*>& devices() { return m_devices; }
+		const BAN::Vector<StorageDevice*>& devices() const { return m_devices; }
+
+	protected:
+		BAN::Vector<StorageDevice*> m_devices;
+	};
+
+}

kernel/include/kernel/Storage/StorageDevice.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <BAN/Vector.h>
+
+namespace Kernel
+{
+
+	struct GUID
+	{
+		uint32_t data1;
+		uint16_t data2;
+		uint16_t data3;
+		uint8_t data4[8];
+	};
+
+	class StorageDevice
+	{
+	public:
+		struct Partition
+		{
+			Partition(StorageDevice&, const GUID&, const GUID&, uint64_t, uint64_t, uint64_t, const char*);
+
+			const GUID& type() const { return m_type; }
+			const GUID& guid() const { return m_guid; }
+			uint64_t lba_start() const { return m_lba_start; }
+			uint64_t lba_end() const { return m_lba_end; }
+			uint64_t attributes() const { return m_attributes; }
+			const char* name() const { return m_name; }
+			const StorageDevice& device() const { return m_device; }
+
+			BAN::ErrorOr<void> read_sectors(uint64_t lba, uint8_t sector_count, uint8_t* buffer);
+			bool is_used() const { uint8_t zero[16] {}; return memcmp(&m_type, zero, 16); }
+
+		private:
+			StorageDevice& m_device;
+			const GUID m_type;
+			const GUID m_guid;
+			const uint64_t m_lba_start;
+			const uint64_t m_lba_end;
+			const uint64_t m_attributes;
+			char m_name[36 * 3 + 1];
+		};
+
+	public:
+		virtual ~StorageDevice() {}
+
+		BAN::ErrorOr<void> initialize_partitions();
+
+		virtual BAN::ErrorOr<void> read_sectors(uint64_t lba, uint8_t sector_count, uint8_t* buffer) = 0;
+		virtual uint32_t sector_size() const = 0;
+		virtual uint64_t total_size() const = 0;
+
+		BAN::Vector<Partition>& partitions() { return m_partitions; }
+
+	private:
+		BAN::Vector<Partition> m_partitions;
+	};
+
+}