Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-29 15:57:59 +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
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
10 changed files with 150 additions and 192 deletions
Show Stats 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; SBIdx = 255;
CHArchTrapFrame *Frame = (CHArchTrapFrame *)Data; CHArchTrapFrame *Frame = (CHArchTrapFrame *)Data;
#if defined(a64) #if defined(a64)
error("-----------------------------------------------------------------------------------");
error("An exception occurred!"); error("An exception occurred!");
error("Exception: %#llx", Frame->InterruptNumber); error("Exception: %#llx", Frame->InterruptNumber);
for (size_t i = 0; i < INT_FRAMES_MAX; i++) 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); debug("driver size %ld", DriversNum);
for (size_t i = 0; i < DriversNum; i++) for (size_t i = 0; i < DriversNum; i++)
{ {
DriverFile *drv = Drivers[i]; DriverFile drv = Drivers[i];
KernelCallback callback; 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);
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; 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); Drivers.remove(i);
} }
} }
@ -59,22 +59,21 @@ namespace Driver
debug("Searching for driver %ld", 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;
callback.Reason = StopReason; callback.Reason = StopReason;
debug("Stopping and unloading driver %ld [%#lx]", drv->DriverUID, drv->Address); debug("Stopping and unloading driver %ld [%#lx]", drv.DriverUID, drv.Address);
this->IOCB(drv->DriverUID, (void *)&callback); 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; 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); Drivers.remove(i);
return true; return true;
} }
@ -86,10 +85,10 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) foreach (auto Drv in Drivers)
{ {
if (Drv->DriverUID == DUID) if (Drv.DriverUID == DUID)
{ {
FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS); FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv.Address + EXTENDED_SECTION_ADDRESS);
int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv->Address))(KCB); int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv.Address))(KCB);
__sync; __sync;
return ret; return ret;
} }
@ -233,14 +232,14 @@ namespace Driver
#endif #endif
{ {
SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */ SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */
if (!Handle->InterruptCallback) if (!Handle.InterruptCallback)
{ {
#if defined(a64) || defined(a32) #if defined(a64) || defined(a32)
int IntNum = Frame->InterruptNumber - 32; int IntNum = Frame->InterruptNumber - 32;
#elif defined(aa64) #elif defined(aa64)
int IntNum = Frame->InterruptNumber; int IntNum = Frame->InterruptNumber;
#endif #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; return;
} }
CPURegisters regs; CPURegisters regs;
@ -287,15 +286,15 @@ namespace Driver
regs.ss = Frame->ss; regs.ss = Frame->ss;
#elif defined(aa64) #elif defined(aa64)
#endif #endif
((int (*)(void *))(Handle->InterruptCallback))(&regs); ((int (*)(void *))(Handle.InterruptCallback))(&regs);
UNUSED(Frame); UNUSED(Frame);
} }
DriverInterruptHook::DriverInterruptHook(int Interrupt, DriverFile *Handle) : Interrupts::Handler(Interrupt) DriverInterruptHook::DriverInterruptHook(int Interrupt, DriverFile Handle) : Interrupts::Handler(Interrupt)
{ {
this->Handle = Handle; this->Handle = Handle;
#if defined(a64) || defined(a32) #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) #elif defined(aa64)
trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID); trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
#endif #endif

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

@ -63,12 +63,12 @@ namespace Driver
fixme("Input driver: %s", fexExtended->Driver.Name); fixme("Input driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->MemTrk = mem; .MemTrk = mem,
DrvFile->InterruptHook[0] = nullptr; };
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }

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

@ -23,7 +23,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -31,7 +31,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -47,7 +47,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -58,12 +58,13 @@ namespace Driver
} }
fixme("Generic driver: %s", fexExtended->Driver.Name); fixme("Generic driver: %s", fexExtended->Driver.Name);
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->MemTrk = mem; .MemTrk = mem,
};
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }
@ -77,7 +78,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -85,7 +86,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -101,7 +102,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -125,7 +126,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -133,7 +134,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -149,7 +150,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -174,7 +175,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -182,7 +183,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -198,7 +199,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -207,20 +208,20 @@ namespace Driver
} }
} }
} }
DriverFile DrvFile = {
DriverFile *DrvFile = new DriverFile; .Enabled = true,
DrvFile->Enabled = true; .DriverUID = this->DriverUIDs - 1,
DrvFile->DriverUID = this->DriverUIDs - 1; .Address = (void *)fex,
DrvFile->Address = (void *)fex; .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .MemTrk = mem,
DrvFile->MemTrk = mem; };
if (fexExtended->Driver.InterruptCallback) if (fexExtended->Driver.InterruptCallback)
{ {
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++) 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) if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break; 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) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
@ -257,7 +256,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -265,7 +264,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -281,7 +280,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -306,7 +305,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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 && if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) || fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
@ -317,7 +316,7 @@ namespace Driver
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
return DriverCode::DRIVER_CONFLICT; 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) 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 && if ((fe->Driver.TypeFlags & FexDriverInputTypes_Mouse &&
fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) || fexExtended->Driver.TypeFlags & FexDriverInputTypes_Mouse) ||
@ -348,19 +347,20 @@ namespace Driver
} }
} }
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->MemTrk = mem; .MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback) if (fexExtended->Driver.InterruptCallback)
{ {
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++) 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) if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break; 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) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
@ -397,7 +395,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -405,7 +403,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -421,7 +419,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) 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>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -144,7 +144,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -160,7 +160,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -184,7 +184,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -192,7 +192,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -208,7 +208,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -232,7 +232,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -240,7 +240,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -256,7 +256,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -266,14 +266,15 @@ namespace Driver
} }
} }
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->MemTrk = mem; .MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback) 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}; KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice; KCallback.RawPtr = PCIDevice;
@ -283,7 +284,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
@ -292,7 +292,6 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
@ -310,7 +309,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -318,7 +317,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -334,7 +333,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -344,14 +343,15 @@ namespace Driver
} }
} }
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->MemTrk = mem; .MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback) 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}; KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice; KCallback.RawPtr = PCIDevice;
@ -361,7 +361,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
@ -370,7 +369,6 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
@ -388,7 +386,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -396,7 +394,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -412,7 +410,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -436,7 +434,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -444,7 +442,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -460,7 +458,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -484,7 +482,7 @@ namespace Driver
std::vector<int> DriversToRemove = std::vector<int>(); std::vector<int> DriversToRemove = std::vector<int>();
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -492,7 +490,7 @@ namespace Driver
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
} }
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv.DriverUID);
} }
foreach (auto DrvID in DriversToRemove) foreach (auto DrvID in DriversToRemove)
@ -508,7 +506,7 @@ namespace Driver
{ {
foreach (auto Drv in Drivers) 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) if (fe->Driver.OverrideOnConflict)
{ {
@ -518,14 +516,15 @@ namespace Driver
} }
} }
DriverFile *DrvFile = new DriverFile; DriverFile DrvFile = {
DrvFile->Enabled = true; .Enabled = true,
DrvFile->DriverUID = this->DriverUIDs - 1; .DriverUID = this->DriverUIDs - 1,
DrvFile->Address = (void *)fex; .Address = (void *)fex,
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback); .InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback),
DrvFile->MemTrk = mem; .MemTrk = mem,
};
if (fexExtended->Driver.InterruptCallback) 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}; KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice; KCallback.RawPtr = PCIDevice;
@ -535,7 +534,6 @@ namespace Driver
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
@ -544,7 +542,6 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }

8
GUI/GraphicalUserInterface.cpp
View File

@ -26,17 +26,17 @@ namespace GraphicalUserInterface
{ {
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
{ {
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Input && if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Input &&
((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.TypeFlags & FexDriverInputTypes::FexDriverInputTypes_Mouse) ((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.TypeFlags & FexDriverInputTypes::FexDriverInputTypes_Mouse)
{ {
#ifdef DEBUG #ifdef DEBUG
static int once = 0; static int once = 0;
if (!once++) if (!once++)
debug("Found mouse driver %ld", Driver->DriverUID); debug("Found mouse driver %ld", Driver.DriverUID);
#endif #endif
KernelCallback callback; KernelCallback callback;
callback.Reason = FetchReason; callback.Reason = FetchReason;
DriverManager->IOCB(Driver->DriverUID, (void *)&callback); DriverManager->IOCB(Driver.DriverUID, (void *)&callback);
Mouse.X = callback.InputCallback.Mouse.X; Mouse.X = callback.InputCallback.Mouse.X;
Mouse.Y = callback.InputCallback.Mouse.Y; Mouse.Y = callback.InputCallback.Mouse.Y;
Mouse.Z = callback.InputCallback.Mouse.Z; Mouse.Z = callback.InputCallback.Mouse.Z;

41
KThread.cpp
View File

@ -226,43 +226,6 @@ void ExitLogoAnimationThread()
uint32_t DispX = Display->GetBuffer(1)->Width; uint32_t DispX = Display->GetBuffer(1)->Width;
uint32_t DispY = Display->GetBuffer(1)->Height; uint32_t DispY = Display->GetBuffer(1)->Height;
// for (size_t i = 26; i > 0; i--)
// {
// int x, y, channels;
// if (!stbi_info_from_memory((uint8_t *)Frames[i], FrameSizes[i], &x, &y, &channels))
// continue;
// uint8_t *img = stbi_load_from_memory((uint8_t *)Frames[i], FrameSizes[i], &x, &y, &channels, 4);
// if (img == NULL)
// continue;
// int offsetX = DispX / 2 - x / 2;
// int offsetY = DispY / 2 - y / 2;
// for (int i = 0; i < x * y; i++)
// {
// uint32_t pixel = ((uint32_t *)img)[i];
// uint8_t r = (pixel >> 16) & 0xFF;
// uint8_t g = (pixel >> 8) & 0xFF;
// uint8_t b = (pixel >> 0) & 0xFF;
// uint8_t a = (pixel >> 24) & 0xFF;
// if (a != 0xFF)
// {
// r = (r * a) / 0xFF;
// g = (g * a) / 0xFF;
// b = (b * a) / 0xFF;
// }
// Display->SetPixel((i % x) + offsetX, (i / x) + offsetY, (r << 16) | (g << 8) | (b << 0), 1);
// }
// free(img);
// Display->SetBuffer(1);
// }
for (size_t i = 40; i > 25; i--) for (size_t i = 40; i > 25; i--)
{ {
int x, y, channels; int x, y, channels;
@ -342,8 +305,8 @@ void KernelMainThread()
if (DriverManager->GetDrivers().size() > 0) if (DriverManager->GetDrivers().size() > 0)
{ {
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Storage) if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Storage)
DiskManager->FetchDisks(Driver->DriverUID); DiskManager->FetchDisks(Driver.DriverUID);
} }
else else
KPrint("\eE85230No disk drivers found! Cannot fetch disks!"); KPrint("\eE85230No disk drivers found! Cannot fetch disks!");

4
Network/NetworkController.cpp
View File

@ -25,8 +25,8 @@ namespace NetworkInterfaceManager
if (DriverManager->GetDrivers().size() > 0) if (DriverManager->GetDrivers().size() > 0)
{ {
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Network) if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Network)
this->FetchNetworkCards(Driver->DriverUID); this->FetchNetworkCards(Driver.DriverUID);
} }
else else
KPrint("\eE85230No network drivers found! Cannot fetch network cards!"); KPrint("\eE85230No network drivers found! Cannot fetch network cards!");

24
Recovery/RecoveryMain.cpp
View File

@ -35,18 +35,18 @@ namespace Recovery
void PlayAudio() void PlayAudio()
{ {
SmartLock(PlayAudioLock); SmartLock(PlayAudioLock);
Driver::DriverFile *AudioDrv = nullptr; Driver::DriverFile AudioDrv;
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
{ {
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio) if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio)
{ {
AudioDrv = Driver; AudioDrv = Driver;
break; break;
} }
} }
if (AudioDrv == nullptr) if (!AudioDrv.Enabled)
{ {
error("No audio drivers found! Cannot play audio!"); error("No audio drivers found! Cannot play audio!");
return; return;
@ -69,7 +69,7 @@ namespace Recovery
callback.AudioCallback.Send.Data = (uint8_t *)PCMRaw; callback.AudioCallback.Send.Data = (uint8_t *)PCMRaw;
callback.AudioCallback.Send.Length = pcm->node->Length; callback.AudioCallback.Send.Length = pcm->node->Length;
debug("Playing audio..."); debug("Playing audio...");
int status = DriverManager->IOCB(AudioDrv->DriverUID, (void *)&callback); int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
debug("Audio played! %d", status); debug("Audio played! %d", status);
KernelAllocator.FreePages((void *)PCMRaw, TO_PAGES(pcm->node->Length)); KernelAllocator.FreePages((void *)PCMRaw, TO_PAGES(pcm->node->Length));
vfs->Close(pcm); vfs->Close(pcm);
@ -79,18 +79,18 @@ namespace Recovery
void ChangeSampleRate(char SR) void ChangeSampleRate(char SR)
{ {
Driver::DriverFile *AudioDrv = nullptr; Driver::DriverFile AudioDrv;
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
{ {
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio) if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio)
{ {
AudioDrv = Driver; AudioDrv = Driver;
break; break;
} }
} }
if (AudioDrv == nullptr) if (!AudioDrv.Enabled)
{ {
error("No audio drivers found! Cannot play audio!"); error("No audio drivers found! Cannot play audio!");
return; return;
@ -101,7 +101,7 @@ namespace Recovery
callback.Reason = AdjustReason; callback.Reason = AdjustReason;
callback.AudioCallback.Adjust._SampleRate = true; callback.AudioCallback.Adjust._SampleRate = true;
callback.AudioCallback.Adjust.SampleRate = SR; callback.AudioCallback.Adjust.SampleRate = SR;
int status = DriverManager->IOCB(AudioDrv->DriverUID, (void *)&callback); int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
debug("Sample rate changed! %d", status); debug("Sample rate changed! %d", status);
} }
@ -117,18 +117,18 @@ namespace Recovery
void ChangeVolume(int percentage) void ChangeVolume(int percentage)
{ {
Driver::DriverFile *AudioDrv = nullptr; Driver::DriverFile AudioDrv;
foreach (auto Driver in DriverManager->GetDrivers()) foreach (auto Driver in DriverManager->GetDrivers())
{ {
if (((FexExtended *)((uintptr_t)Driver->Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio) if (((FexExtended *)((uintptr_t)Driver.Address + EXTENDED_SECTION_ADDRESS))->Driver.Type == FexDriverType::FexDriverType_Audio)
{ {
AudioDrv = Driver; AudioDrv = Driver;
break; break;
} }
} }
if (AudioDrv == nullptr) if (!AudioDrv.Enabled)
{ {
error("No audio drivers found! Cannot play audio!"); error("No audio drivers found! Cannot play audio!");
return; return;
@ -139,7 +139,7 @@ namespace Recovery
callback.Reason = AdjustReason; callback.Reason = AdjustReason;
callback.AudioCallback.Adjust._Volume = true; callback.AudioCallback.Adjust._Volume = true;
callback.AudioCallback.Adjust.Volume = percentage; callback.AudioCallback.Adjust.Volume = percentage;
int status = DriverManager->IOCB(AudioDrv->DriverUID, (void *)&callback); int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
debug("Volume changed! %d", status); debug("Volume changed! %d", status);
} }

20
include/driver.hpp
View File

@ -30,18 +30,18 @@ namespace Driver
class DriverInterruptHook; class DriverInterruptHook;
struct DriverFile struct DriverFile
{ {
bool Enabled; bool Enabled = false;
unsigned long DriverUID; unsigned long DriverUID = 0;
void *Address; void *Address = nullptr;
void *InterruptCallback; void *InterruptCallback = nullptr;
Memory::MemMgr *MemTrk; Memory::MemMgr *MemTrk = nullptr;
DriverInterruptHook *InterruptHook[16]; DriverInterruptHook *InterruptHook[16] = {nullptr};
}; };
class DriverInterruptHook : public Interrupts::Handler class DriverInterruptHook : public Interrupts::Handler
{ {
private: private:
DriverFile *Handle; DriverFile Handle;
#if defined(a64) #if defined(a64)
void OnInterruptReceived(CPU::x64::TrapFrame *Frame); void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
@ -52,14 +52,14 @@ namespace Driver
#endif #endif
public: public:
DriverInterruptHook(int Interrupt, DriverFile *Handle); DriverInterruptHook(int Interrupt, DriverFile Handle);
virtual ~DriverInterruptHook() = default; virtual ~DriverInterruptHook() = default;
}; };
class Driver class Driver
{ {
private: private:
std::vector<DriverFile *> Drivers; std::vector<DriverFile> Drivers;
unsigned long DriverUIDs = 0; unsigned long DriverUIDs = 0;
DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress); DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress);
@ -101,7 +101,7 @@ namespace Driver
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:
std::vector<DriverFile *> GetDrivers() { return Drivers; } std::vector<DriverFile> GetDrivers() { return Drivers; }
void UnloadAllDrivers(); void UnloadAllDrivers();
bool UnloadDriver(unsigned long DUID); bool UnloadDriver(unsigned long DUID);
int IOCB(unsigned long DUID, /* KernelCallback */ void *KCB); int IOCB(unsigned long DUID, /* KernelCallback */ void *KCB);