mirror of
https://github.com/EnderIce2/Fennix.git
synced 2025-07-14 00:39:16 +00:00
Merge remote-tracking branch 'Kernel/multiboot2_64' into Kernel-multiboot2_64
This commit is contained in:
120
Kernel/Core/Driver/DriverLoading/BindInput.cpp
Normal file
120
Kernel/Core/Driver/DriverLoading/BindInput.cpp
Normal file
@ -0,0 +1,120 @@
|
||||
#include "../api.hpp"
|
||||
|
||||
#include <ints.hpp>
|
||||
#include <memory.hpp>
|
||||
#include <task.hpp>
|
||||
#include <lock.hpp>
|
||||
#include <printf.h>
|
||||
#include <cwalk.h>
|
||||
#include <md5.h>
|
||||
|
||||
#include "../../../kernel.h"
|
||||
#include "../../../DAPI.hpp"
|
||||
#include "../../../Fex.hpp"
|
||||
|
||||
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, mem = nullptr;
|
||||
error("Driver %s is not implemented", fexExtended->Driver.Name);
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
else if (CallbackRet != DriverReturnCode::OK)
|
||||
{
|
||||
delete mem, mem = nullptr;
|
||||
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)
|
||||
{
|
||||
UNUSED(DrvExtHdr);
|
||||
UNUSED(IsElf);
|
||||
Memory::MemMgr *mem = new Memory::MemMgr(nullptr, TaskManager->GetCurrentProcess()->memDirectory);
|
||||
Fex *fex = (Fex *)mem->RequestPages(TO_PAGES(Size));
|
||||
memcpy(fex, (void *)DriverAddress, Size);
|
||||
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
|
||||
debug("Driver allocated at %#lx-%#lx", fex, (uintptr_t)fex + Size);
|
||||
#ifdef DEBUG
|
||||
uint8_t *result = md5File((uint8_t *)fex, Size);
|
||||
debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7],
|
||||
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
|
||||
kfree(result);
|
||||
#endif
|
||||
KernelAPI *KAPI = (KernelAPI *)mem->RequestPages(TO_PAGES(sizeof(KernelAPI)));
|
||||
|
||||
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
|
||||
{
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::DRIVER_RETURNED_ERROR;
|
||||
}
|
||||
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
|
||||
|
||||
switch (fexExtended->Driver.Type)
|
||||
{
|
||||
case FexDriverType::FexDriverType_Input:
|
||||
return BindInputInput(mem, fex);
|
||||
default:
|
||||
{
|
||||
warn("Unknown driver type: %d", fexExtended->Driver.Type);
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::UNKNOWN_DRIVER_TYPE;
|
||||
}
|
||||
}
|
||||
|
||||
return DriverCode::OK;
|
||||
}
|
||||
}
|
469
Kernel/Core/Driver/DriverLoading/BindInterrupt.cpp
Normal file
469
Kernel/Core/Driver/DriverLoading/BindInterrupt.cpp
Normal file
@ -0,0 +1,469 @@
|
||||
#include "../api.hpp"
|
||||
|
||||
#include <ints.hpp>
|
||||
#include <memory.hpp>
|
||||
#include <task.hpp>
|
||||
#include <lock.hpp>
|
||||
#include <printf.h>
|
||||
#include <cwalk.h>
|
||||
#include <md5.h>
|
||||
|
||||
#include "../../../kernel.h"
|
||||
#include "../../../DAPI.hpp"
|
||||
#include "../../../Fex.hpp"
|
||||
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Display driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Network driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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, mem = nullptr;
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
else if (CallbackRet != DriverReturnCode::OK)
|
||||
{
|
||||
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
DriverCode Driver::BindInterruptInput(Memory::MemMgr *mem, void *fex)
|
||||
{
|
||||
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
|
||||
|
||||
debug("Searching for conflicting drivers...");
|
||||
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.TypeFlags & FexDriverInputTypes_Mouse &&
|
||||
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
|
||||
(fe->Driver.TypeFlags & FexDriverInputTypes_Keyboard &&
|
||||
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Keyboard))
|
||||
{
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
|
||||
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
|
||||
(fe->Driver.TypeFlags & FexDriverInputTypes_Keyboard &&
|
||||
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Keyboard))
|
||||
{
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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, InterruptHook = nullptr;
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
else if (CallbackRet != DriverReturnCode::OK)
|
||||
{
|
||||
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
|
||||
delete InterruptHook, InterruptHook = nullptr;
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Audio driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
|
||||
{
|
||||
UNUSED(IsElf);
|
||||
Memory::MemMgr *mem = new Memory::MemMgr(nullptr, TaskManager->GetCurrentProcess()->memDirectory);
|
||||
Fex *fex = (Fex *)mem->RequestPages(TO_PAGES(Size));
|
||||
memcpy(fex, (void *)DriverAddress, Size);
|
||||
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
|
||||
debug("Driver allocated at %#lx-%#lx", fex, (uintptr_t)fex + Size);
|
||||
#ifdef DEBUG
|
||||
uint8_t *result = md5File((uint8_t *)fex, Size);
|
||||
debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7],
|
||||
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
|
||||
kfree(result);
|
||||
#endif
|
||||
KernelAPI *KAPI = (KernelAPI *)mem->RequestPages(TO_PAGES(sizeof(KernelAPI)));
|
||||
|
||||
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
|
||||
{
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::DRIVER_RETURNED_ERROR;
|
||||
}
|
||||
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
|
||||
|
||||
switch (fexExtended->Driver.Type)
|
||||
{
|
||||
case FexDriverType::FexDriverType_Generic:
|
||||
return BindInterruptGeneric(mem, fex);
|
||||
case FexDriverType::FexDriverType_Display:
|
||||
return BindInterruptDisplay(mem, fex);
|
||||
case FexDriverType::FexDriverType_Network:
|
||||
return BindInterruptNetwork(mem, fex);
|
||||
case FexDriverType::FexDriverType_Storage:
|
||||
return BindInterruptStorage(mem, fex);
|
||||
case FexDriverType::FexDriverType_FileSystem:
|
||||
return BindInterruptFileSystem(mem, fex);
|
||||
case FexDriverType::FexDriverType_Input:
|
||||
return BindInterruptInput(mem, fex);
|
||||
case FexDriverType::FexDriverType_Audio:
|
||||
return BindInterruptAudio(mem, fex);
|
||||
default:
|
||||
{
|
||||
warn("Unknown driver type: %d", fexExtended->Driver.Type);
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::UNKNOWN_DRIVER_TYPE;
|
||||
}
|
||||
}
|
||||
|
||||
return DriverCode::OK;
|
||||
}
|
||||
}
|
600
Kernel/Core/Driver/DriverLoading/BindPCI.cpp
Normal file
600
Kernel/Core/Driver/DriverLoading/BindPCI.cpp
Normal file
@ -0,0 +1,600 @@
|
||||
#include "../api.hpp"
|
||||
|
||||
#include <ints.hpp>
|
||||
#include <memory.hpp>
|
||||
#include <task.hpp>
|
||||
#include <lock.hpp>
|
||||
#include <printf.h>
|
||||
#include <cwalk.h>
|
||||
#include <md5.h>
|
||||
|
||||
#include "../../../kernel.h"
|
||||
#include "../../../DAPI.hpp"
|
||||
#include "../../../Fex.hpp"
|
||||
|
||||
namespace Driver
|
||||
{
|
||||
void Driver::MapPCIAddresses(PCI::PCIDeviceHeader *PCIDevice)
|
||||
{
|
||||
Memory::Virtual vma = Memory::Virtual(nullptr);
|
||||
|
||||
debug("Header Type: %d", PCIDevice->HeaderType);
|
||||
switch (PCIDevice->HeaderType)
|
||||
{
|
||||
case 0: // PCI Header 0
|
||||
{
|
||||
uint32_t BAR[6] = {0};
|
||||
size_t BARsSize[6] = {0};
|
||||
|
||||
BAR[0] = ((PCI::PCIHeader0 *)PCIDevice)->BAR0;
|
||||
BAR[1] = ((PCI::PCIHeader0 *)PCIDevice)->BAR1;
|
||||
BAR[2] = ((PCI::PCIHeader0 *)PCIDevice)->BAR2;
|
||||
BAR[3] = ((PCI::PCIHeader0 *)PCIDevice)->BAR3;
|
||||
BAR[4] = ((PCI::PCIHeader0 *)PCIDevice)->BAR4;
|
||||
BAR[5] = ((PCI::PCIHeader0 *)PCIDevice)->BAR5;
|
||||
|
||||
uintptr_t BAR_Type = BAR[0] & 1;
|
||||
uintptr_t BAR_IOBase = BAR[1] & (~3);
|
||||
uintptr_t BAR_MemoryBase = BAR[0] & (~15);
|
||||
|
||||
debug("Type: %d; IOBase: %#lx; MemoryBase: %#lx", BAR_Type, BAR_IOBase, BAR_MemoryBase);
|
||||
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
{
|
||||
if (BAR[i] == 0)
|
||||
continue;
|
||||
debug("BAR%d: %#lx", i, BAR[i]);
|
||||
}
|
||||
|
||||
/* BARs Size */
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
{
|
||||
if (BAR[i] == 0)
|
||||
continue;
|
||||
|
||||
if ((BAR[i] & 1) == 0) // Memory Base
|
||||
{
|
||||
((PCI::PCIHeader0 *)PCIDevice)->BAR0 = 0xFFFFFFFF;
|
||||
size_t size = ((PCI::PCIHeader0 *)PCIDevice)->BAR0;
|
||||
((PCI::PCIHeader0 *)PCIDevice)->BAR0 = BAR[i];
|
||||
BARsSize[i] = size & (~15);
|
||||
BARsSize[i] = ~BARsSize[i] + 1;
|
||||
BARsSize[i] = BARsSize[i] & 0xFFFFFFFF;
|
||||
debug("BAR%dSize: %#lx", i, BARsSize[i]);
|
||||
}
|
||||
else if ((BAR[i] & 1) == 1) // I/O Base
|
||||
{
|
||||
((PCI::PCIHeader0 *)PCIDevice)->BAR1 = 0xFFFFFFFF;
|
||||
size_t size = ((PCI::PCIHeader0 *)PCIDevice)->BAR1;
|
||||
((PCI::PCIHeader0 *)PCIDevice)->BAR1 = BAR[i];
|
||||
BARsSize[i] = size & (~3);
|
||||
BARsSize[i] = ~BARsSize[i] + 1;
|
||||
BARsSize[i] = BARsSize[i] & 0xFFFF;
|
||||
debug("BAR%dSize: %#lx", i, BARsSize[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/* Mapping the BARs */
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
{
|
||||
if (BAR[i] == 0)
|
||||
continue;
|
||||
|
||||
if ((BAR[i] & 1) == 0) // Memory Base
|
||||
{
|
||||
uintptr_t BARBase = BAR[i] & (~15);
|
||||
size_t BARSize = BARsSize[i];
|
||||
|
||||
debug("Mapping BAR%d from %#lx to %#lx", i, BARBase, BARBase + BARSize);
|
||||
for (uintptr_t j = BARBase;
|
||||
j < (BARBase + BARSize);
|
||||
j += PAGE_SIZE)
|
||||
{
|
||||
vma.Map((void *)j, (void *)j, Memory::PTFlag::RW | Memory::PTFlag::PWT);
|
||||
}
|
||||
}
|
||||
else if ((BAR[i] & 1) == 1) // I/O Base
|
||||
{
|
||||
uintptr_t BARBase = BAR[i] & (~3);
|
||||
uintptr_t BARSize = BARsSize[i];
|
||||
|
||||
debug("Mapping BAR%d from %#x to %#x", i, BARBase, BARBase + BARSize);
|
||||
for (uintptr_t j = BARBase;
|
||||
j < (BARBase + BARSize);
|
||||
j += PAGE_SIZE)
|
||||
{
|
||||
vma.Map((void *)j, (void *)j, Memory::PTFlag::RW | Memory::PTFlag::PWT);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 1: // PCI Header 1 (PCI-to-PCI Bridge)
|
||||
{
|
||||
fixme("PCI Header 1 (PCI-to-PCI Bridge) not implemented yet");
|
||||
break;
|
||||
}
|
||||
case 2: // PCI Header 2 (PCI-to-CardBus Bridge)
|
||||
{
|
||||
fixme("PCI Header 2 (PCI-to-CardBus Bridge) not implemented yet");
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
error("Unknown header type %d", PCIDevice->HeaderType);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Generic driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Display driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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, mem = nullptr;
|
||||
delete InterruptHook, InterruptHook = nullptr;
|
||||
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, mem = nullptr;
|
||||
delete InterruptHook, InterruptHook = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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, mem = nullptr;
|
||||
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, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
|
||||
fixme("Input driver: %s", fexExtended->Driver.Name);
|
||||
delete mem, mem = nullptr;
|
||||
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));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
|
||||
DriversToRemove.push_back(Drv->DriverUID);
|
||||
}
|
||||
|
||||
foreach (auto DrvID in DriversToRemove)
|
||||
{
|
||||
if (!this->UnloadDriver(DrvID))
|
||||
{
|
||||
error("Failed to unload conflicting driver %d", DrvID);
|
||||
return DriverCode::DRIVER_CONFLICT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (auto Drv in Drivers)
|
||||
{
|
||||
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
|
||||
|
||||
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
|
||||
if (fe->Driver.OverrideOnConflict)
|
||||
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, mem = nullptr;
|
||||
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, mem = nullptr;
|
||||
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::DriverLoadBindPCI(void *DrvExtHdr, uintptr_t DriverAddress, size_t Size, bool IsElf)
|
||||
{
|
||||
UNUSED(IsElf);
|
||||
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++)
|
||||
{
|
||||
if (Vidx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) && Didx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID))
|
||||
break;
|
||||
|
||||
if (((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[Vidx] == 0 || ((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[Didx] == 0)
|
||||
continue;
|
||||
|
||||
Vector<PCI::PCIDeviceHeader *> devices = PCIManager->FindPCIDevice(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[Vidx], ((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[Didx]);
|
||||
if (devices.size() == 0)
|
||||
continue;
|
||||
|
||||
foreach (auto PCIDevice in devices)
|
||||
{
|
||||
debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID);
|
||||
Memory::MemMgr *mem = new Memory::MemMgr(nullptr, TaskManager->GetCurrentProcess()->memDirectory);
|
||||
Fex *fex = (Fex *)mem->RequestPages(TO_PAGES(Size));
|
||||
memcpy(fex, (void *)DriverAddress, Size);
|
||||
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
|
||||
debug("Driver allocated at %#lx-%#lx", fex, (uintptr_t)fex + Size);
|
||||
#ifdef DEBUG
|
||||
uint8_t *result = md5File((uint8_t *)fex, Size);
|
||||
debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7],
|
||||
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
|
||||
kfree(result);
|
||||
#endif
|
||||
KernelAPI *KAPI = (KernelAPI *)mem->RequestPages(TO_PAGES(sizeof(KernelAPI)));
|
||||
|
||||
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
|
||||
{
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::DRIVER_RETURNED_ERROR;
|
||||
}
|
||||
debug("Starting driver %s", fexExtended->Driver.Name);
|
||||
|
||||
MapPCIAddresses(PCIDevice);
|
||||
|
||||
switch (fexExtended->Driver.Type)
|
||||
{
|
||||
case FexDriverType::FexDriverType_Generic:
|
||||
return BindPCIGeneric(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_Display:
|
||||
return BindPCIDisplay(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_Network:
|
||||
return BindPCINetwork(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_Storage:
|
||||
return BindPCIStorage(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_FileSystem:
|
||||
return BindPCIFileSystem(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_Input:
|
||||
return BindPCIInput(mem, fex, PCIDevice);
|
||||
case FexDriverType::FexDriverType_Audio:
|
||||
return BindPCIAudio(mem, fex, PCIDevice);
|
||||
default:
|
||||
{
|
||||
warn("Unknown driver type: %d", fexExtended->Driver.Type);
|
||||
delete mem, mem = nullptr;
|
||||
return DriverCode::UNKNOWN_DRIVER_TYPE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return DriverCode::PCI_DEVICE_NOT_FOUND;
|
||||
}
|
||||
}
|
60
Kernel/Core/Driver/DriverLoading/BindProcess.cpp
Normal file
60
Kernel/Core/Driver/DriverLoading/BindProcess.cpp
Normal file
@ -0,0 +1,60 @@
|
||||
#include "../api.hpp"
|
||||
|
||||
#include <ints.hpp>
|
||||
#include <memory.hpp>
|
||||
#include <task.hpp>
|
||||
#include <lock.hpp>
|
||||
#include <printf.h>
|
||||
#include <cwalk.h>
|
||||
#include <md5.h>
|
||||
|
||||
#include "../../../kernel.h"
|
||||
#include "../../../DAPI.hpp"
|
||||
#include "../../../Fex.hpp"
|
||||
|
||||
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)
|
||||
{
|
||||
fixme("Process driver: %s", ((FexExtended *)DrvExtHdr)->Driver.Name);
|
||||
UNUSED(Size);
|
||||
UNUSED(DriverAddress);
|
||||
UNUSED(IsElf);
|
||||
return DriverCode::NOT_IMPLEMENTED;
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user