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

Improved driver loading/unloading

Browse Source
This commit is contained in:
Alex 2022-12-18 14:31:02 +02:00
parent 02f592ede9
commit e4ec9d87b8
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
7 changed files with 70 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Core/Driver/Driver.cpp
View File

@ -39,6 +39,7 @@ namespace Driver
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;
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])
@ -59,6 +60,7 @@ namespace Driver
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;
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])
@ -81,16 +83,15 @@ namespace Driver
return -1; return -1;
} }
DriverCode Driver::CallDriverEntryPoint(void *fex) DriverCode Driver::CallDriverEntryPoint(void *fex, void *KAPIAddress)
{ {
KernelAPI *API = (KernelAPI *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelAPI))); memcpy(KAPIAddress, &KernelAPITemplate, sizeof(KernelAPI));
memcpy(API, &KAPI, sizeof(KernelAPI));
API->Info.Offset = (unsigned long)fex; ((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex;
API->Info.DriverUID = DriverUIDs++; ((KernelAPI *)KAPIAddress)->Info.DriverUID = DriverUIDs++;
debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, API->Info.DriverUID); debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, ((KernelAPI *)KAPIAddress)->Info.DriverUID);
int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->EntryPoint + (uint64_t)fex))(API); int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->EntryPoint + (uint64_t)fex))(((KernelAPI *)KAPIAddress));
if (DriverReturnCode::OK != ret) if (DriverReturnCode::OK != ret)
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;

2
Core/Driver/DriverAPI.cpp
View File

@ -91,7 +91,7 @@ char *DriverPCIGetDeviceName(unsigned int VendorID, unsigned int DeviceID)
return (char *)"Unknown"; return (char *)"Unknown";
} }
KernelAPI KAPI = { KernelAPI KernelAPITemplate = {
.Version = { .Version = {
.Major = 0, .Major = 0,
.Minor = 0, .Minor = 0,

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

@ -16,7 +16,8 @@ namespace Driver
{ {
DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf)
{ {
Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); Memory::Tracker *Tracker = new Memory::Tracker;
Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
memcpy(fex, (void *)DriverAddress, Size); memcpy(fex, (void *)DriverAddress, Size);
FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@ -27,14 +28,16 @@ namespace Driver
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
kfree(result); kfree(result);
#endif #endif
if (CallDriverEntryPoint(fex) != DriverCode::OK) KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
switch (fexExtended->Driver.Type) switch (fexExtended->Driver.Type)
{ {
@ -47,25 +50,23 @@ namespace Driver
int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
break; break;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
break; break;
} }
KernelAllocator.FreePages(fex, TO_PAGES(Size)); fixme("Input driver: %s", fexExtended->Driver.Name);
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
DriverFile *DrvFile = new DriverFile; DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1; DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex; DrvFile->Address = (void *)fex;
DrvFile->MemTrk = Tracker;
DrvFile->InterruptHook[0] = nullptr; DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
break; break;
@ -73,6 +74,7 @@ namespace Driver
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete Tracker;
break; break;
} }
} }

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

@ -16,7 +16,8 @@ namespace Driver
{ {
DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf)
{ {
Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); Memory::Tracker *Tracker = new Memory::Tracker;
Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
memcpy(fex, (void *)DriverAddress, Size); memcpy(fex, (void *)DriverAddress, Size);
FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@ -27,14 +28,16 @@ namespace Driver
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
kfree(result); kfree(result);
#endif #endif
if (CallDriverEntryPoint(fex) != DriverCode::OK) KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
switch (fexExtended->Driver.Type) switch (fexExtended->Driver.Type)
{ {
@ -44,17 +47,20 @@ namespace Driver
DriverFile *DrvFile = new DriverFile; DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1; DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex; DrvFile->Address = (void *)fex;
DrvFile->MemTrk = Tracker;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
break; break;
} }
case FexDriverType::FexDriverType_Display: case FexDriverType::FexDriverType_Display:
{ {
fixme("Display driver: %s", fexExtended->Driver.Name); fixme("Display driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Network: case FexDriverType::FexDriverType_Network:
{ {
fixme("Network driver: %s", fexExtended->Driver.Name); fixme("Network driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Storage: case FexDriverType::FexDriverType_Storage:
@ -68,8 +74,7 @@ namespace Driver
} }
fixme("Not implemented"); fixme("Not implemented");
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
break; break;
KCallback->RawPtr = nullptr; KCallback->RawPtr = nullptr;
@ -77,29 +82,28 @@ namespace Driver
int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete Tracker;
break; break;
} }
KernelAllocator.FreePages(fex, TO_PAGES(Size)); DriverFile *DrvFile = new DriverFile;
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
// DriverFile *DrvFile = new DriverFile; DrvFile->MemTrk = Tracker;
// Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
break; break;
} }
case FexDriverType::FexDriverType_FileSystem: case FexDriverType::FexDriverType_FileSystem:
{ {
fixme("Filesystem driver: %s", fexExtended->Driver.Name); fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Input: case FexDriverType::FexDriverType_Input:
@ -125,16 +129,16 @@ namespace Driver
int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
delete InterruptHook;
delete Tracker;
break; break;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete InterruptHook;
delete Tracker;
break; break;
} }
@ -144,6 +148,7 @@ namespace Driver
DriverFile *DrvFile = new DriverFile; DriverFile *DrvFile = new DriverFile;
DrvFile->DriverUID = this->DriverUIDs - 1; DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex; DrvFile->Address = (void *)fex;
DrvFile->MemTrk = Tracker;
DrvFile->InterruptHook[0] = InterruptHook; DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
break; break;
@ -151,11 +156,13 @@ namespace Driver
case FexDriverType::FexDriverType_Audio: case FexDriverType::FexDriverType_Audio:
{ {
fixme("Audio driver: %s", fexExtended->Driver.Name); fixme("Audio driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete Tracker;
break; break;
} }
} }

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

@ -31,7 +31,8 @@ namespace Driver
foreach (auto PCIDevice in devices) foreach (auto PCIDevice in devices)
{ {
debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID); debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID);
Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); Memory::Tracker *Tracker = new Memory::Tracker();
Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
memcpy(fex, (void *)DriverAddress, Size); memcpy(fex, (void *)DriverAddress, Size);
FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@ -42,14 +43,16 @@ namespace Driver
result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
kfree(result); kfree(result);
#endif #endif
if (CallDriverEntryPoint(fex) != DriverCode::OK) KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size)); delete Tracker;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
debug("Starting driver %s", fexExtended->Driver.Name); debug("Starting driver %s", fexExtended->Driver.Name);
KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
debug("Type: %d; IOBase: %#x; MemoryBase: %#x", debug("Type: %d; IOBase: %#x; MemoryBase: %#x",
((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1, ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1,
@ -82,11 +85,13 @@ namespace Driver
case FexDriverType::FexDriverType_Generic: case FexDriverType::FexDriverType_Generic:
{ {
fixme("Generic driver: %s", fexExtended->Driver.Name); fixme("Generic driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Display: case FexDriverType::FexDriverType_Display:
{ {
fixme("Display driver: %s", fexExtended->Driver.Name); fixme("Display driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Network: case FexDriverType::FexDriverType_Network:
@ -100,20 +105,18 @@ namespace Driver
int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
delete InterruptHook;
error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
delete Tracker;
delete InterruptHook;
continue; continue;
} }
else if (CallbackRet == DriverReturnCode::OK) else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name); trace("Device found for driver: %s", fexExtended->Driver.Name);
else else
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
delete InterruptHook;
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete Tracker;
delete InterruptHook;
continue; continue;
} }
@ -134,18 +137,16 @@ namespace Driver
int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
delete Tracker;
continue; continue;
} }
else if (CallbackRet == DriverReturnCode::OK) else if (CallbackRet == DriverReturnCode::OK)
trace("Device found for driver: %s", fexExtended->Driver.Name); trace("Device found for driver: %s", fexExtended->Driver.Name);
else else
{ {
KernelAllocator.FreePages(fex, TO_PAGES(Size));
KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete Tracker;
continue; continue;
} }
@ -159,21 +160,25 @@ namespace Driver
case FexDriverType::FexDriverType_FileSystem: case FexDriverType::FexDriverType_FileSystem:
{ {
fixme("Filesystem driver: %s", fexExtended->Driver.Name); fixme("Filesystem driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Input: case FexDriverType::FexDriverType_Input:
{ {
fixme("Input driver: %s", fexExtended->Driver.Name); fixme("Input driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
case FexDriverType::FexDriverType_Audio: case FexDriverType::FexDriverType_Audio:
{ {
fixme("Audio driver: %s", fexExtended->Driver.Name); fixme("Audio driver: %s", fexExtended->Driver.Name);
delete Tracker;
break; break;
} }
default: default:
{ {
warn("Unknown driver type: %d", fexExtended->Driver.Type); warn("Unknown driver type: %d", fexExtended->Driver.Type);
delete Tracker;
break; break;
} }
} }

2
Core/Driver/api.hpp
View File

@ -5,6 +5,6 @@
#include "../../DAPI.hpp" #include "../../DAPI.hpp"
extern KernelAPI KAPI; extern KernelAPI KernelAPITemplate;
#endif // !__FENNIX_KERNEL_DRIVER_API_H__ #endif // !__FENNIX_KERNEL_DRIVER_API_H__

4
include/driver.hpp
View File

@ -5,6 +5,7 @@
#include <interrupts.hpp> #include <interrupts.hpp>
#include <vector.hpp> #include <vector.hpp>
#include <memory.hpp>
#include <debug.h> #include <debug.h>
#include <cpu.hpp> #include <cpu.hpp>
@ -46,6 +47,7 @@ namespace Driver
{ {
unsigned long DriverUID; unsigned long DriverUID;
void *Address; void *Address;
Memory::Tracker *MemTrk;
DriverInterruptHook *InterruptHook[16]; DriverInterruptHook *InterruptHook[16];
}; };
@ -55,7 +57,7 @@ namespace Driver
Vector<DriverFile *> Drivers; Vector<DriverFile *> Drivers;
unsigned long DriverUIDs = 0; unsigned long DriverUIDs = 0;
DriverCode CallDriverEntryPoint(void *fex); DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress);
DriverCode DriverLoadBindPCI(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); DriverCode DriverLoadBindPCI(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);
DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);
DriverCode DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); DriverCode DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);