Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-07-08 05:49:17 +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
6 changed files with 751 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -14,11 +14,273 @@
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)
{
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 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))
@ -55,8 +317,6 @@ namespace Driver
}
debug("Starting driver %s", fexExtended->Driver.Name);
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
debug("Type: %d; IOBase: %#x; MemoryBase: %#x",
((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1,
((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3),
@ -87,111 +347,70 @@ namespace Driver
{
case FexDriverType::FexDriverType_Generic:
{
fixme("Generic driver: %s", fexExtended->Driver.Name);
delete mem;
break;
DriverCode ret = BindPCIGeneric(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_Display:
{
fixme("Display driver: %s", fexExtended->Driver.Name);
delete mem;
break;
DriverCode ret = BindPCIDisplay(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_Network:
{
DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)devices[0])->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;
DriverCode ret = BindPCINetwork(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
}
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;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_Storage:
{
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;
DriverCode ret = BindPCIStorage(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
}
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;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_FileSystem:
{
fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete mem;
break;
DriverCode ret = BindPCIFileSystem(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_Input:
{
fixme("Input driver: %s", fexExtended->Driver.Name);
delete mem;
break;
DriverCode ret = BindPCIInput(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
}
case FexDriverType::FexDriverType_Audio:
{
fixme("Audio driver: %s", fexExtended->Driver.Name);
delete mem;
break;
DriverCode ret = BindPCIAudio(mem, fex, PCIDevice);
if (ret != DriverCode::OK &&
ret != DriverCode::DRIVER_CONFLICT)
continue;
return DriverCode::OK;
}
default:
{
warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete mem;
break;
return DriverCode::UNKNOWN_DRIVER_TYPE;
}
}
IsDriverLoaded = true;
}
}
if (IsDriverLoaded)
return DriverCode::OK;
else
return DriverCode::NOT_AVAILABLE;
}
return DriverCode::PCI_DEVICE_NOT_FOUND;
}
}