Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-07-11 15:29:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactor driver file creation to use structured binding

Browse Source
This commit is contained in:
Alex
2023-03-26 21:20:12 +03:00
parent e6c103c671
commit f4641e21fe
10 changed files with 150 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Core/Crash/CrashHandler.cpp
View File

@ -792,6 +792,7 @@ namespace CrashHandler
SBIdx = 255;
CHArchTrapFrame *Frame = (CHArchTrapFrame *)Data;
#if defined(a64)
error("-----------------------------------------------------------------------------------");
error("An exception occurred!");
error("Exception: %#llx", Frame->InterruptNumber);
for (size_t i = 0; i < INT_FRAMES_MAX; i++)

49
Core/Driver/Driver.cpp
View File

@ -36,20 +36,20 @@ namespace Driver
debug("driver size %ld", DriversNum);
for (size_t i = 0; i < DriversNum; i++)
{
DriverFile *drv = Drivers[i];
DriverFile drv = Drivers[i];
KernelCallback callback;
callback.Reason = StopReason;
debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
DriverManager->IOCB(drv->DriverUID, (void *)&callback);
debug("Stopping & unloading driver %ld [%#lx]", drv.DriverUID, drv.Address);
DriverManager->IOCB(drv.DriverUID, (void *)&callback);
delete drv->MemTrk, drv->MemTrk = nullptr;
for (size_t j = 0; j < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); j++)
for (size_t j = 0; j < sizeof(drv.InterruptHook) / sizeof(drv.InterruptHook[0]); j++)
{
if (!drv->InterruptHook[j])
if (!drv.InterruptHook[j])
continue;
delete drv->InterruptHook[j], drv->InterruptHook[j] = nullptr;
delete drv.InterruptHook[j], drv.InterruptHook[j] = nullptr;
}
delete drv, drv = nullptr;
if (drv.MemTrk)
delete drv.MemTrk, drv.MemTrk = nullptr;
Drivers.remove(i);
}
}
@ -59,22 +59,21 @@ namespace Driver
debug("Searching for driver %ld", DUID);
for (size_t i = 0; i < Drivers.size(); i++)
{
DriverFile *drv = Drivers[i];
if (drv->DriverUID == DUID)
DriverFile drv = Drivers[i];
if (drv.DriverUID == DUID)
{
KernelCallback callback;
callback.Reason = StopReason;
debug("Stopping and unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
this->IOCB(drv->DriverUID, (void *)&callback);
debug("Stopping and unloading driver %ld [%#lx]", drv.DriverUID, drv.Address);
this->IOCB(drv.DriverUID, (void *)&callback);
delete drv->MemTrk, drv->MemTrk = nullptr;
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++)
{
if (!drv->InterruptHook[i])
if (!drv.InterruptHook[i])
continue;
delete drv->InterruptHook[i], drv->InterruptHook[i] = nullptr;
delete drv.InterruptHook[i], drv.InterruptHook[i] = nullptr;
}
delete drv, drv = nullptr;
delete drv.MemTrk, drv.MemTrk = nullptr;
Drivers.remove(i);
return true;
}
@ -86,10 +85,10 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
if (Drv->DriverUID == DUID)
if (Drv.DriverUID == DUID)
{
FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS);
int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv->Address))(KCB);
FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS);
int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv.Address))(KCB);
__sync;
return ret;
}
@ -233,14 +232,14 @@ namespace Driver
#endif
{
SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */
if (!Handle->InterruptCallback)
if (!Handle.InterruptCallback)
{
#if defined(a64) || defined(a32)
int IntNum = Frame->InterruptNumber - 32;
#elif defined(aa64)
int IntNum = Frame->InterruptNumber;
#endif
warn("Interrupt callback for %ld is not set for driver %ld!", IntNum, Handle->DriverUID);
warn("Interrupt callback for %ld is not set for driver %ld!", IntNum, Handle.DriverUID);
return;
}
CPURegisters regs;
@ -287,15 +286,15 @@ namespace Driver
regs.ss = Frame->ss;
#elif defined(aa64)
#endif
((int (*)(void *))(Handle->InterruptCallback))(&regs);
((int (*)(void *))(Handle.InterruptCallback))(&regs);
UNUSED(Frame);
}
DriverInterruptHook::DriverInterruptHook(int Interrupt, DriverFile *Handle) : Interrupts::Handler(Interrupt)
DriverInterruptHook::DriverInterruptHook(int Interrupt, DriverFile Handle) : Interrupts::Handler(Interrupt)
{
this->Handle = Handle;
#if defined(a64) || defined(a32)
trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
trace("Interrupt %d hooked to driver %ld", Interrupt, Handle.DriverUID);
#elif defined(aa64)
trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
#endif

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

@ -63,12 +63,12 @@ namespace Driver
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;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.MemTrk = mem,
};
Drivers.push_back(DrvFile);
return DriverCode::OK;
}

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

@ -23,7 +23,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -31,7 +31,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -47,7 +47,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -58,12 +58,13 @@ namespace Driver
}
fixme("Generic driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
Drivers.push_back(DrvFile);
return DriverCode::OK;
}
@ -77,7 +78,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -85,7 +86,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -101,7 +102,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -125,7 +126,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -133,7 +134,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -149,7 +150,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -174,7 +175,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -182,7 +183,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -198,7 +199,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -207,20 +208,20 @@ namespace Driver
}
}
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback)
{
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;
DrvFile->InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
DrvFile.InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
}
}
@ -232,14 +233,12 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = 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 DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
@ -257,7 +256,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -265,7 +264,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -281,7 +280,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -306,7 +305,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
@ -317,7 +316,7 @@ namespace Driver
if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT;
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
}
@ -334,7 +333,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
@ -348,19 +347,20 @@ namespace Driver
}
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback)
{
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;
DrvFile->InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
DrvFile.InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
}
}
@ -372,14 +372,12 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = 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 DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
@ -397,7 +395,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -405,7 +403,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -421,7 +419,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{

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

@ -136,7 +136,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -144,7 +144,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -160,7 +160,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -184,7 +184,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -192,7 +192,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -208,7 +208,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -232,7 +232,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -240,7 +240,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -256,7 +256,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -266,14 +266,15 @@ namespace Driver
}
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
DrvFile.InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice;
@ -283,7 +284,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED;
}
@ -292,7 +292,6 @@ namespace Driver
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
@ -310,7 +309,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -318,7 +317,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -334,7 +333,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -344,14 +343,15 @@ namespace Driver
}
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
DrvFile.InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice;
@ -361,7 +361,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED;
}
@ -370,7 +369,6 @@ namespace Driver
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
@ -388,7 +386,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -396,7 +394,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -412,7 +410,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -436,7 +434,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -444,7 +442,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -460,7 +458,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -484,7 +482,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -492,7 +490,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID);
DriversToRemove.push_back(Drv.DriverUID);
}
foreach (auto DrvID in DriversToRemove)
@ -508,7 +506,7 @@ namespace Driver
{
foreach (auto Drv in Drivers)
{
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS));
if (fe->Driver.OverrideOnConflict)
{
@ -518,14 +516,15 @@ namespace Driver
}
}
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
DriverFile DrvFile = {
.Enabled = true,
.DriverUID = this->DriverUIDs - 1,
.Address = (void *)fex,
.InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
.MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
DrvFile.InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice;
@ -535,7 +534,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED;
}
@ -544,7 +542,6 @@ namespace Driver
else
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}