Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-28 15:34:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated driver loading code

Browse Source
This commit is contained in:
Alex 2023-03-02 02:32:55 +02:00
parent 784d7726df
commit 645578894e
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
6 changed files with 751 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Core/Driver/Driver.cpp
View File

@ -30,13 +30,12 @@ namespace Driver
void Driver::UnloadAllDrivers() void Driver::UnloadAllDrivers()
{ {
KernelCallback callback;
debug("%ld drivers loaded, [DUIDs: %ld]", Drivers.size(), DriverUIDs); debug("%ld drivers loaded, [DUIDs: %ld]", Drivers.size(), DriverUIDs);
debug("driver size %ld", Drivers.size()); debug("driver size %ld", Drivers.size());
for (size_t i = 0; i < Drivers.size(); i++) for (size_t i = 0; i < Drivers.size(); i++)
{ {
DriverFile *drv = Drivers[i]; DriverFile *drv = Drivers[i];
memset(&callback, 0, sizeof(KernelCallback)); KernelCallback callback;
callback.Reason = StopReason; callback.Reason = StopReason;
debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address); debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
DriverManager->IOCB(drv->DriverUID, (void *)&callback); DriverManager->IOCB(drv->DriverUID, (void *)&callback);
@ -54,16 +53,16 @@ namespace Driver
bool Driver::UnloadDriver(unsigned long DUID) bool Driver::UnloadDriver(unsigned long DUID)
{ {
debug("Searching for driver %ld", DUID);
for (size_t i = 0; i < Drivers.size(); i++) for (size_t i = 0; i < Drivers.size(); i++)
{ {
DriverFile *drv = Drivers[i]; DriverFile *drv = Drivers[i];
if (drv->DriverUID == DUID) if (drv->DriverUID == DUID)
{ {
KernelCallback callback; KernelCallback callback;
memset(&callback, 0, sizeof(KernelCallback));
callback.Reason = StopReason; callback.Reason = StopReason;
debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address); debug("Stopping and unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
DriverManager->IOCB(drv->DriverUID, (void *)&callback); this->IOCB(drv->DriverUID, (void *)&callback);
delete drv->MemTrk; delete drv->MemTrk;
for (size_t i = 0; i < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); i++) for (size_t i = 0; i < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); i++)
@ -81,12 +80,16 @@ namespace Driver
int Driver::IOCB(unsigned long DUID, void *KCB) int Driver::IOCB(unsigned long DUID, void *KCB)
{ {
foreach (auto var in Drivers) foreach (auto Drv in Drivers)
if (var->DriverUID == DUID) {
if (Drv->DriverUID == DUID)
{ {
FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)var->Address + EXTENDED_SECTION_ADDRESS); FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS);
return ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)var->Address))(KCB); int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv->Address))(KCB);
__sync;
return ret;
} }
}
return -1; return -1;
} }

98
Core/Driver/DriverLoading/BindInput.cpp
View File

@ -14,6 +14,70 @@
namespace Driver namespace Driver
{ {
DriverCode Driver::BindInputGeneric(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInputDisplay(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInputNetwork(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInputStorage(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInputFileSystem(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInputInput(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
fixme("Input driver: %s", fexExtended->Driver.Name);
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
delete mem;
error("Driver %s is not implemented", fexExtended->Driver.Name);
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet != DriverReturnCode::OK)
{
delete mem;
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
return DriverCode::DRIVER_RETURNED_ERROR;
}
fixme("Input driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindInputAudio(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf) DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
{ {
UNUSED(DrvExtHdr); UNUSED(DrvExtHdr);
@ -39,45 +103,15 @@ namespace Driver
} }
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
switch (fexExtended->Driver.Type) switch (fexExtended->Driver.Type)
{ {
case FexDriverType::FexDriverType_Input: case FexDriverType::FexDriverType_Input:
{ return BindInputInput(mem, fex);
fixme("Input driver: %s", fexExtended->Driver.Name);
KCallback->RawPtr = nullptr;
break;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
delete mem;
error("Driver %s is not implemented", fexExtended->Driver.Name);
break;
}
else if (CallbackRet != DriverReturnCode::OK)
{
delete mem;
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
break;
}
fixme("Input driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile);
break;
}
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete mem; delete mem;
break; return DriverCode::UNKNOWN_DRIVER_TYPE;
} }
} }

416
Core/Driver/DriverLoading/BindInterrupt.cpp
View File

@ -14,6 +14,300 @@
namespace Driver namespace Driver
{ {
DriverCode Driver::BindInterruptGeneric(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Generic driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindInterruptDisplay(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Display driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInterruptNetwork(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Network driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInterruptStorage(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED; // FIXME
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
UNUSED(KCallback); // Shut up clang
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break;
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", fexExtended->Driver.Bind.Interrupt.Vector[i]);
}
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
return DriverCode::DRIVER_RETURNED_ERROR;
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindInterruptFileSystem(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindInterruptInput(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
debug("Searching for conflicting drivers...");
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
(fe->Driver.TypeFlags & FexDriverInputTypes_Keyboard &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Keyboard))
{
DriversToRemove.push_back(Drv->DriverUID);
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
}
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
DriverInterruptHook *InterruptHook = nullptr;
if (fexExtended->Driver.Bind.Interrupt.Vector[0] != 0)
InterruptHook = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[0] + 32, // x86
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
KCallback);
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break;
// InterruptHook = new DriverInterruptHook((fexExtended->Driver.Bind.Interrupt.Vector[i] + 32, // x86
// (void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
// KCallback);
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", fexExtended->Driver.Bind.Interrupt.Vector[i]);
}
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete InterruptHook;
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete InterruptHook;
delete mem;
return DriverCode::DRIVER_RETURNED_ERROR;
}
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindInterruptAudio(Memory::MemMgr *mem, void *fex)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Audio driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf) DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
{ {
UNUSED(IsElf); UNUSED(IsElf);
@ -38,133 +332,27 @@ namespace Driver
} }
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
switch (fexExtended->Driver.Type) switch (fexExtended->Driver.Type)
{ {
case FexDriverType::FexDriverType_Generic: case FexDriverType::FexDriverType_Generic:
{ return BindInterruptGeneric(mem, fex);
fixme("Generic driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
Drivers.push_back(DrvFile);
break;
}
case FexDriverType::FexDriverType_Display: case FexDriverType::FexDriverType_Display:
{ return BindInterruptDisplay(mem, fex);
fixme("Display driver: %s", fexExtended->Driver.Name);
delete mem;
break;
}
case FexDriverType::FexDriverType_Network: case FexDriverType::FexDriverType_Network:
{ return BindInterruptNetwork(mem, fex);
fixme("Network driver: %s", fexExtended->Driver.Name);
delete mem;
break;
}
case FexDriverType::FexDriverType_Storage: case FexDriverType::FexDriverType_Storage:
{ return BindInterruptStorage(mem, fex);
for (unsigned long i = 0; i < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] == 0)
break;
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", ((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i]);
}
fixme("Not implemented");
delete mem;
break;
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
break;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
break;
}
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
Drivers.push_back(DrvFile);
break;
}
case FexDriverType::FexDriverType_FileSystem: case FexDriverType::FexDriverType_FileSystem:
{ return BindInterruptFileSystem(mem, fex);
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete mem;
break;
}
case FexDriverType::FexDriverType_Input: case FexDriverType::FexDriverType_Input:
{ return BindInterruptInput(mem, fex);
DriverInterruptHook *InterruptHook = nullptr;
if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0] != 0)
InterruptHook = new DriverInterruptHook(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0] + 32, // x86
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
KCallback);
for (unsigned long i = 0; i < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] == 0)
break;
// InterruptHook = new DriverInterruptHook(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] + 32, // x86
// (void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
// KCallback);
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", ((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i]);
}
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete InterruptHook;
delete mem;
break;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete InterruptHook;
delete mem;
break;
}
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile);
break;
}
case FexDriverType::FexDriverType_Audio: case FexDriverType::FexDriverType_Audio:
{ return BindInterruptAudio(mem, fex);
fixme("Audio driver: %s", fexExtended->Driver.Name);
delete mem;
break;
}
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete mem; delete mem;
break; return DriverCode::UNKNOWN_DRIVER_TYPE;
} }
} }

379
Core/Driver/DriverLoading/BindPCI.cpp
View File

@ -14,11 +14,273 @@
namespace Driver namespace Driver
{ {
DriverCode Driver::BindPCIGeneric(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Generic driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindPCIDisplay(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Display driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindPCINetwork(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine) + 32, // x86
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
KCallback);
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
delete InterruptHook;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name);
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
delete InterruptHook;
return DriverCode::DRIVER_RETURNED_ERROR;
}
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindPCIStorage(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name);
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
return DriverCode::DRIVER_RETURNED_ERROR;
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
DriverCode Driver::BindPCIFileSystem(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindPCIInput(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Input driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindPCIAudio(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice)
{
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict)
{
Vector<int> DriversToRemove = Vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
}
foreach (auto DrvID in DriversToRemove)
{
if (!this->UnloadDriver(DrvID))
{
error("Failed to unload conflicting driver %d", DrvID);
return DriverCode::DRIVER_CONFLICT;
}
}
}
fixme("Audio driver: %s", fexExtended->Driver.Name);
delete mem;
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::DriverLoadBindPCI(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf) DriverCode Driver::DriverLoadBindPCI(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
{ {
UNUSED(IsElf); UNUSED(IsElf);
bool IsDriverLoaded = false;
for (unsigned long Vidx = 0; Vidx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[0]); Vidx++) for (unsigned long Vidx = 0; Vidx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[0]); Vidx++)
{
for (unsigned long Didx = 0; Didx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[0]); Didx++) for (unsigned long Didx = 0; Didx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[0]); Didx++)
{ {
if (Vidx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) && Didx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID)) if (Vidx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) && Didx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID))
@ -55,8 +317,6 @@ namespace Driver
} }
debug("Starting driver %s", fexExtended->Driver.Name); debug("Starting driver %s", fexExtended->Driver.Name);
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
debug("Type: %d; IOBase: %#x; MemoryBase: %#x", debug("Type: %d; IOBase: %#x; MemoryBase: %#x",
((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1, ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1,
((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3), ((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3),
@ -87,111 +347,70 @@ namespace Driver
{ {
case FexDriverType::FexDriverType_Generic: case FexDriverType::FexDriverType_Generic:
{ {
fixme("Generic driver: %s", fexExtended->Driver.Name); DriverCode ret = BindPCIGeneric(mem, fex, PCIDevice);
delete mem; if (ret != DriverCode::OK &&
break; ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
} }
case FexDriverType::FexDriverType_Display: case FexDriverType::FexDriverType_Display:
{ {
fixme("Display driver: %s", fexExtended->Driver.Name); DriverCode ret = BindPCIDisplay(mem, fex, PCIDevice);
delete mem; if (ret != DriverCode::OK &&
break; ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
} }
case FexDriverType::FexDriverType_Network: case FexDriverType::FexDriverType_Network:
{ {
DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)devices[0])->InterruptLine) + 32, // x86 DriverCode ret = BindPCINetwork(mem, fex, PCIDevice);
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex), if (ret != DriverCode::OK &&
KCallback); ret != DriverCode::DRIVER_CONFLICT)
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
delete InterruptHook;
continue; continue;
} return DriverCode::OK;
else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name);
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
delete InterruptHook;
continue;
}
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile);
break;
} }
case FexDriverType::FexDriverType_Storage: case FexDriverType::FexDriverType_Storage:
{ {
KCallback->RawPtr = PCIDevice; DriverCode ret = BindPCIStorage(mem, fex, PCIDevice);
KCallback->Reason = CallbackReason::ConfigurationReason; if (ret != DriverCode::OK &&
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback); ret != DriverCode::DRIVER_CONFLICT)
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem;
continue; continue;
} return DriverCode::OK;
else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name);
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem;
continue;
}
DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile);
break;
} }
case FexDriverType::FexDriverType_FileSystem: case FexDriverType::FexDriverType_FileSystem:
{ {
fixme("Filesystem driver: %s", fexExtended->Driver.Name); DriverCode ret = BindPCIFileSystem(mem, fex, PCIDevice);
delete mem; if (ret != DriverCode::OK &&
break; ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
} }
case FexDriverType::FexDriverType_Input: case FexDriverType::FexDriverType_Input:
{ {
fixme("Input driver: %s", fexExtended->Driver.Name); DriverCode ret = BindPCIInput(mem, fex, PCIDevice);
delete mem; if (ret != DriverCode::OK &&
break; ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
} }
case FexDriverType::FexDriverType_Audio: case FexDriverType::FexDriverType_Audio:
{ {
fixme("Audio driver: %s", fexExtended->Driver.Name); DriverCode ret = BindPCIAudio(mem, fex, PCIDevice);
delete mem; if (ret != DriverCode::OK &&
break; ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
} }
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete mem; delete mem;
break; return DriverCode::UNKNOWN_DRIVER_TYPE;
} }
} }
IsDriverLoaded = true;
} }
} }
}
if (IsDriverLoaded) return DriverCode::PCI_DEVICE_NOT_FOUND;
return DriverCode::OK;
else
return DriverCode::NOT_AVAILABLE;
} }
} }

35
Core/Driver/DriverLoading/BindProcess.cpp
View File

@ -14,6 +14,41 @@
namespace Driver namespace Driver
{ {
DriverCode Driver::BindProcessGeneric(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessDisplay(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessNetwork(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessStorage(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessFileSystem(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessInput(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::BindProcessAudio(Memory::MemMgr *mem, void *fex)
{
return DriverCode::NOT_IMPLEMENTED;
}
DriverCode Driver::DriverLoadBindProcess(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf) DriverCode Driver::DriverLoadBindProcess(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
{ {
fixme("Process driver: %s", ((FexExtended *)DrvExtHdr)->Driver.Name); fixme("Process driver: %s", ((FexExtended *)DrvExtHdr)->Driver.Name);

40
include/driver.hpp
View File

@ -3,11 +3,12 @@
#include <types.h> #include <types.h>
#include <ints.hpp>
#include <vector.hpp> #include <vector.hpp>
#include <memory.hpp> #include <memory.hpp>
#include <ints.hpp>
#include <debug.h> #include <debug.h>
#include <cpu.hpp> #include <cpu.hpp>
#include <pci.hpp>
namespace Driver namespace Driver
{ {
@ -22,7 +23,8 @@ namespace Driver
NOT_IMPLEMENTED, NOT_IMPLEMENTED,
DRIVER_RETURNED_ERROR, DRIVER_RETURNED_ERROR,
UNKNOWN_DRIVER_TYPE, UNKNOWN_DRIVER_TYPE,
PCI_DEVICE_NOT_FOUND PCI_DEVICE_NOT_FOUND,
DRIVER_CONFLICT
}; };
class DriverInterruptHook : public Interrupts::Handler class DriverInterruptHook : public Interrupts::Handler
@ -46,6 +48,7 @@ namespace Driver
struct DriverFile struct DriverFile
{ {
bool Enabled;
unsigned long DriverUID; unsigned long DriverUID;
void *Address; void *Address;
Memory::MemMgr *MemTrk; Memory::MemMgr *MemTrk;
@ -57,11 +60,42 @@ namespace Driver
private: private:
Vector<DriverFile *> Drivers; Vector<DriverFile *> Drivers;
unsigned long DriverUIDs = 0; unsigned long DriverUIDs = 0;
DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress); DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress);
DriverCode BindPCIGeneric(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCIDisplay(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCINetwork(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCIStorage(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCIFileSystem(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCIInput(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode BindPCIAudio(Memory::MemMgr *mem, void *fex, PCI::PCIDeviceHeader *PCIDevice);
DriverCode DriverLoadBindPCI(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false); DriverCode DriverLoadBindPCI(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false);
DriverCode BindInterruptGeneric(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptDisplay(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptNetwork(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptStorage(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptFileSystem(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptInput(Memory::MemMgr *mem, void *fex);
DriverCode BindInterruptAudio(Memory::MemMgr *mem, void *fex);
DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false); DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false);
DriverCode BindInputGeneric(Memory::MemMgr *mem, void *fex);
DriverCode BindInputDisplay(Memory::MemMgr *mem, void *fex);
DriverCode BindInputNetwork(Memory::MemMgr *mem, void *fex);
DriverCode BindInputStorage(Memory::MemMgr *mem, void *fex);
DriverCode BindInputFileSystem(Memory::MemMgr *mem, void *fex);
DriverCode BindInputInput(Memory::MemMgr *mem, void *fex);
DriverCode BindInputAudio(Memory::MemMgr *mem, void *fex);
DriverCode DriverLoadBindInput(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false); DriverCode DriverLoadBindInput(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false);
DriverCode BindProcessGeneric(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessDisplay(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessNetwork(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessStorage(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessFileSystem(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessInput(Memory::MemMgr *mem, void *fex);
DriverCode BindProcessAudio(Memory::MemMgr *mem, void *fex);
DriverCode DriverLoadBindProcess(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false); DriverCode DriverLoadBindProcess(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf = false);
public: public: