Now with a simple driver interface.

include/Tier1/CKernel.h

@@ -3,10 +3,12 @@
 
 #include "types.h"
 #include "Tier1/CLogger.h"
+#include "Tier1/Drivers/CDriverManager.h"
 
 #define CKERNEL_MAGIC 0x8BA67FE9
 
 namespace cb {
+    class CDriverManager;
     class CKernel {
         public:
             CKernel(void);
@@ -15,6 +17,7 @@ namespace cb {
         private:
             u32 m_Magic;
             CLogger *m_Logger;
+            CDriverManager *m_DriverManager;
     };
 };
 

include/Tier1/Drivers/CDriverManager.h

@@ -0,0 +1,38 @@
+#ifndef __CDRIVERMANAGER_H__
+#define __CDRIVERMANAGER_H__
+
+#include "types.h"
+#include "Tier1/Drivers/IDriver.h"
+#include "Tier1/CKernel.h"
+
+namespace cb {
+    class IDriver;
+    class CKernel;
+    
+    typedef struct {
+        const s8 *Name;
+        IDriver *Driver;
+        bool New;
+        bool Loaded;
+        bool Present;
+    } CDriverManagerEntry;
+    class CDriverManager {
+        public:
+            CDriverManager(u32 MaxDrivers, CKernel *Kernel);
+            void AddDriver(IDriver *Driver);
+
+            void LoadDriver(s8 *Name);
+            void LoadAll(void);
+            void LoadNew(void);
+            
+            void UnloadDriver(s8 *Name);
+        private:
+            CDriverManagerEntry *m_aDrivers;
+            u32 m_nMaxDrivers;
+            CKernel *m_Kernel;
+            
+            void LoadDriver(u32 Index);
+    };
+};
+
+#endif

include/Tier1/Drivers/IDriver.h

@@ -0,0 +1,34 @@
+#ifndef __IDRIVER_H__
+#define __IDRIVER_H__
+
+#include "types.h"
+#include "Tier1/CKernel.h"
+
+namespace cb {
+    class CKernel;
+    
+    enum EDriverClass {
+        EDC_NONE,
+        EDC_FILESYSTEM,
+        BDC_BLOCKDEVICE
+    };
+    enum EDriverLoadMethod {
+        EDLM_ALWAYS = 1,
+        EDLM_PCIPRESENT = 2,
+        EDLM_USBPRESENT = 4
+    };
+    class IDriver {
+        public:
+            virtual const s8 *GetName(void) = 0;
+            virtual const s8 *GetDescription(void) = 0;
+            virtual const s8 *GetAuthor(void) = 0;
+            virtual EDriverClass GetClass(void) = 0;
+            virtual EDriverLoadMethod GetLoadMethod(void) = 0;
+            virtual bool CanUnload(void) = 0;
+            
+            virtual u8 Load(CKernel *Kernel) = 0;
+            virtual u8 Unload(void) = 0;
+    };
+};
+
+#endif

include/Tier1/Drivers/Misc/CDriverDummy.h

@@ -0,0 +1,25 @@
+// A dummy driver that says hello.
+
+#ifndef __CDRIVERDUMMY_H__
+#define __CDRIVERDUMMY_H__
+
+#include "Tier1/Drivers/IDriver.h"
+
+namespace cb {
+    class CDriverDummy : public IDriver {
+        public:
+            const s8 *GetName(void);
+            const s8 *GetDescription(void);
+            const s8 *GetAuthor(void);
+            EDriverClass GetClass(void);
+            EDriverLoadMethod GetLoadMethod(void);
+            bool CanUnload(void);
+            
+            u8 Load(CKernel *Kernel);
+            u8 Unload(void);
+        private:
+            CKernel *m_Kernel;
+    };
+};
+
+#endif

src/Tier1/CKernel.cpp

@@ -1,4 +1,5 @@
 #include "Tier1/CKernel.h"
+#include "Tier1/Drivers/Misc/CDriverDummy.h"
 using namespace cb;
 
 CKernel g_Kernel;
@@ -33,9 +34,13 @@ void CKernel::Start(void)
     }
     
     m_Logger = new CLogger();
+    m_DriverManager = new CDriverManager(64, this);
+    
+    IDriver *Dummy = new CDriverDummy();
+    m_DriverManager->AddDriver(Dummy);
+    
+    m_DriverManager->LoadNew();
     
-    Logger() << "FUCK YEAH C++!";
-    Logger().Flush();
     
     for (;;) {}
 }

src/Tier1/Drivers/CDriverManager.cpp

@@ -0,0 +1,60 @@
+#include "Tier1/Drivers/CDriverManager.h"
+using namespace cb;
+
+CDriverManager::CDriverManager(u32 MaxDrivers, CKernel *Kernel)
+{
+    m_Kernel = Kernel;
+
+    m_aDrivers = new CDriverManagerEntry[MaxDrivers];
+    m_nMaxDrivers = MaxDrivers;
+    for (u32 i = 0; i < m_nMaxDrivers; i++)
+        m_aDrivers[i].Present = false;
+}
+
+void CDriverManager::AddDriver(IDriver *Driver)
+{
+    u32 Index = 0;
+    while (m_aDrivers[Index].Present)
+        Index++;
+    
+    m_aDrivers[Index].Name = Driver->GetName();
+    m_aDrivers[Index].Present = true;
+    m_aDrivers[Index].New = true;
+    m_aDrivers[Index].Loaded = false;
+    m_aDrivers[Index].Driver = Driver;
+    
+    m_Kernel->Logger() << "Added driver " << Driver->GetName() << ".";
+    m_Kernel->Logger().Flush();
+}
+
+void CDriverManager::LoadNew(void)
+{
+    for (u32 i = 0; i < m_nMaxDrivers; i++)
+    {
+        if (m_aDrivers[i].Present && m_aDrivers[i].New)
+        {
+            m_aDrivers[i].New = false;
+            LoadDriver(i);
+        }
+    }
+}
+
+void CDriverManager::LoadDriver(u32 Index)
+{
+    IDriver *Driver = m_aDrivers[Index].Driver;
+    m_Kernel->Logger() << "Loading driver " << Driver->GetName() << ".";
+    m_Kernel->Logger().Flush();
+    
+    u8 Result = Driver->Load(m_Kernel);
+    if (Result == 0)
+    {
+        m_aDrivers[Index].Loaded = true;
+        m_Kernel->Logger() << "Success.";
+        m_Kernel->Logger().Flush();
+    }
+    else
+    {
+        m_Kernel->Logger() << "Failure.";
+        m_Kernel->Logger().Flush();
+    }
+}

src/Tier1/Drivers/Misc/CDriverDummy.cpp

@@ -0,0 +1,48 @@
+#include "Tier1/Drivers/Misc/CDriverDummy.h"
+using namespace cb;
+
+const s8 *CDriverDummy::GetDescription(void)
+{
+    return "Dummy Driver";
+}
+
+const s8 *CDriverDummy::GetName(void)
+{
+    return "org.q3k.drivers.dummy";
+}
+
+const s8 *CDriverDummy::GetAuthor(void)
+{
+    return "Sergiusz Bazanski";
+}
+
+EDriverClass CDriverDummy::GetClass(void)
+{
+    return EDC_NONE;
+}
+
+EDriverLoadMethod CDriverDummy::GetLoadMethod(void)
+{
+    return EDLM_ALWAYS;
+}
+
+bool CDriverDummy::CanUnload(void)
+{
+    return true;
+}
+
+u8 CDriverDummy::Load(CKernel *Kernel)
+{
+    m_Kernel = Kernel;
+    Kernel->Logger() << "Dummy driver loaded!";
+    Kernel->Logger().Flush();
+    
+    return 0;
+}
+
+u8 CDriverDummy::Unload(void)
+{
+    m_Kernel->Logger() << "Dummy driver unloaded!";
+    m_Kernel->Logger().Flush();
+    return 0;
+}