mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-09-12 20:42:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Kernel/GPU: Rename GenericGraphicsAdapter => GPUDevice

Browse source 
GenericGraphicsAdapter is mouthful. Also, the idea is to move towards a
more advanced subsystem that handles GPUs, not merely graphics adapters.
This commit is contained in:
Liav A. 2024-02-24 18:05:15 +02:00 • committed by Andrew Kaster
commit 69a3602237
Notes: sideshowbarker 2024-07-17 08:34:29 +09:00
14 changed files with 29 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Devices/GPU/3dfx/GraphicsAdapter.cpp
View file

@ -34,7 +34,7 @@ UNMAP_AFTER_INIT ErrorOr<bool> VoodooGraphicsAdapter::probe(PCI::DeviceIdentifie
return id.vendor_id == PCI::VendorID::Tdfx && is_supported_model(id.device_id); return id.vendor_id == PCI::VendorID::Tdfx && is_supported_model(id.device_id);
} }
UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> VoodooGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<GPUDevice>> VoodooGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier)
{ {
auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) VoodooGraphicsAdapter(pci_device_identifier))); auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) VoodooGraphicsAdapter(pci_device_identifier)));
MUST(adapter->initialize_adapter(pci_device_identifier)); MUST(adapter->initialize_adapter(pci_device_identifier));

6
Kernel/Devices/GPU/3dfx/GraphicsAdapter.h
View file

@ -9,16 +9,16 @@
#include <AK/Types.h> #include <AK/Types.h>
#include <Kernel/Bus/PCI/Device.h> #include <Kernel/Bus/PCI/Device.h>
#include <Kernel/Devices/GPU/Console/GenericFramebufferConsole.h> #include <Kernel/Devices/GPU/Console/GenericFramebufferConsole.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h> #include <Kernel/Devices/GPU/GPUDevice.h>
namespace Kernel { namespace Kernel {
class VoodooGraphicsAdapter final : public GenericGraphicsAdapter class VoodooGraphicsAdapter final : public GPUDevice
, public PCI::Device { , public PCI::Device {
public: public:
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&); static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
static ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> create(PCI::DeviceIdentifier const&); static ErrorOr<NonnullLockRefPtr<GPUDevice>> create(PCI::DeviceIdentifier const&);
virtual ~VoodooGraphicsAdapter() = default; virtual ~VoodooGraphicsAdapter() = default;
virtual StringView device_name() const override { return "VoodooGraphicsAdapter"sv; } virtual StringView device_name() const override { return "VoodooGraphicsAdapter"sv; }

2
Kernel/Devices/GPU/Bochs/GraphicsAdapter.cpp
View file

@ -33,7 +33,7 @@ UNMAP_AFTER_INIT ErrorOr<bool> BochsGraphicsAdapter::probe(PCI::DeviceIdentifier
return false; return false;
} }
UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> BochsGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<GPUDevice>> BochsGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier)
{ {
auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) BochsGraphicsAdapter(pci_device_identifier))); auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) BochsGraphicsAdapter(pci_device_identifier)));
MUST(adapter->initialize_adapter(pci_device_identifier)); MUST(adapter->initialize_adapter(pci_device_identifier));

6
Kernel/Devices/GPU/Bochs/GraphicsAdapter.h
View file

@ -10,7 +10,7 @@
#include <Kernel/Bus/PCI/Device.h> #include <Kernel/Bus/PCI/Device.h>
#include <Kernel/Devices/GPU/Bochs/Definitions.h> #include <Kernel/Devices/GPU/Bochs/Definitions.h>
#include <Kernel/Devices/GPU/Console/GenericFramebufferConsole.h> #include <Kernel/Devices/GPU/Console/GenericFramebufferConsole.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h> #include <Kernel/Devices/GPU/GPUDevice.h>
#include <Kernel/Memory/PhysicalAddress.h> #include <Kernel/Memory/PhysicalAddress.h>
#include <Kernel/Memory/TypedMapping.h> #include <Kernel/Memory/TypedMapping.h>
@ -19,13 +19,13 @@ namespace Kernel {
class GraphicsManagement; class GraphicsManagement;
struct BochsDisplayMMIORegisters; struct BochsDisplayMMIORegisters;
class BochsGraphicsAdapter final : public GenericGraphicsAdapter class BochsGraphicsAdapter final : public GPUDevice
, public PCI::Device { , public PCI::Device {
friend class GraphicsManagement; friend class GraphicsManagement;
public: public:
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&); static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
static ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> create(PCI::DeviceIdentifier const&); static ErrorOr<NonnullLockRefPtr<GPUDevice>> create(PCI::DeviceIdentifier const&);
virtual ~BochsGraphicsAdapter() = default; virtual ~BochsGraphicsAdapter() = default;
virtual StringView device_name() const override { return "BochsGraphicsAdapter"sv; } virtual StringView device_name() const override { return "BochsGraphicsAdapter"sv; }

2
Kernel/Devices/GPU/Console/Console.h
View file

@ -8,7 +8,7 @@
#include <AK/AtomicRefCounted.h> #include <AK/AtomicRefCounted.h>
#include <AK/Types.h> #include <AK/Types.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h> #include <Kernel/Devices/GPU/GPUDevice.h>
namespace Kernel::Graphics { namespace Kernel::Graphics {

10
Kernel/Devices/GPU/GenericGraphicsAdapter.h → Kernel/Devices/GPU/GPUDevice.h
View file

@ -13,14 +13,14 @@
#include <Kernel/Memory/PhysicalAddress.h> #include <Kernel/Memory/PhysicalAddress.h>
namespace Kernel { namespace Kernel {
class GenericGraphicsAdapter class GPUDevice
: public AtomicRefCounted<GenericGraphicsAdapter> : public AtomicRefCounted<GPUDevice>
, public LockWeakable<GenericGraphicsAdapter> { , public LockWeakable<GPUDevice> {
public: public:
virtual ~GenericGraphicsAdapter() = default; virtual ~GPUDevice() = default;
protected: protected:
GenericGraphicsAdapter() = default; GPUDevice() = default;
}; };
} }

4
Kernel/Devices/GPU/Intel/NativeGraphicsAdapter.cpp
View file

@ -32,7 +32,7 @@ ErrorOr<bool> IntelNativeGraphicsAdapter::probe(PCI::DeviceIdentifier const& pci
return is_supported_model(pci_device_identifier.hardware_id().device_id); return is_supported_model(pci_device_identifier.hardware_id().device_id);
} }
ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> IntelNativeGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) ErrorOr<NonnullLockRefPtr<GPUDevice>> IntelNativeGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier)
{ {
auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) IntelNativeGraphicsAdapter(pci_device_identifier))); auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) IntelNativeGraphicsAdapter(pci_device_identifier)));
TRY(adapter->initialize_adapter()); TRY(adapter->initialize_adapter());
@ -67,7 +67,7 @@ ErrorOr<void> IntelNativeGraphicsAdapter::initialize_adapter()
} }
IntelNativeGraphicsAdapter::IntelNativeGraphicsAdapter(PCI::DeviceIdentifier const& pci_device_identifier) IntelNativeGraphicsAdapter::IntelNativeGraphicsAdapter(PCI::DeviceIdentifier const& pci_device_identifier)
: GenericGraphicsAdapter() : GPUDevice()
, PCI::Device(const_cast<PCI::DeviceIdentifier&>(pci_device_identifier)) , PCI::Device(const_cast<PCI::DeviceIdentifier&>(pci_device_identifier))
{ {
} }

4
Kernel/Devices/GPU/Intel/NativeGraphicsAdapter.h
View file

@ -17,12 +17,12 @@
namespace Kernel { namespace Kernel {
class IntelNativeGraphicsAdapter final class IntelNativeGraphicsAdapter final
: public GenericGraphicsAdapter : public GPUDevice
, public PCI::Device { , public PCI::Device {
public: public:
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&); static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
static ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> create(PCI::DeviceIdentifier const&); static ErrorOr<NonnullLockRefPtr<GPUDevice>> create(PCI::DeviceIdentifier const&);
virtual ~IntelNativeGraphicsAdapter() = default; virtual ~IntelNativeGraphicsAdapter() = default;

2
Kernel/Devices/GPU/Management.cpp
View file

@ -123,7 +123,7 @@ static inline bool is_display_controller_pci_device(PCI::DeviceIdentifier const&
struct PCIGraphicsDriverInitializer { struct PCIGraphicsDriverInitializer {
ErrorOr<bool> (*probe)(PCI::DeviceIdentifier const&) = nullptr; ErrorOr<bool> (*probe)(PCI::DeviceIdentifier const&) = nullptr;
ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> (*create)(PCI::DeviceIdentifier const&) = nullptr; ErrorOr<NonnullLockRefPtr<GPUDevice>> (*create)(PCI::DeviceIdentifier const&) = nullptr;
}; };
static constexpr PCIGraphicsDriverInitializer s_initializers[] = { static constexpr PCIGraphicsDriverInitializer s_initializers[] = {

4
Kernel/Devices/GPU/Management.h
View file

@ -15,8 +15,8 @@
#include <Kernel/Bus/PCI/Definitions.h> #include <Kernel/Bus/PCI/Definitions.h>
#include <Kernel/Devices/GPU/Console/Console.h> #include <Kernel/Devices/GPU/Console/Console.h>
#include <Kernel/Devices/GPU/DisplayConnector.h> #include <Kernel/Devices/GPU/DisplayConnector.h>
#include <Kernel/Devices/GPU/GPUDevice.h>
#include <Kernel/Devices/GPU/Generic/DisplayConnector.h> #include <Kernel/Devices/GPU/Generic/DisplayConnector.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h>
#include <Kernel/Devices/GPU/VirtIO/GraphicsAdapter.h> #include <Kernel/Devices/GPU/VirtIO/GraphicsAdapter.h>
#include <Kernel/Library/NonnullLockRefPtr.h> #include <Kernel/Library/NonnullLockRefPtr.h>
#include <Kernel/Memory/Region.h> #include <Kernel/Memory/Region.h>
@ -53,7 +53,7 @@ private:
void initialize_preset_resolution_generic_display_connector(); void initialize_preset_resolution_generic_display_connector();
Vector<NonnullLockRefPtr<GenericGraphicsAdapter>> m_graphics_devices; Vector<NonnullLockRefPtr<GPUDevice>> m_graphics_devices;
LockRefPtr<Graphics::Console> m_console; LockRefPtr<Graphics::Console> m_console;
// Note: This is only used when booting with kernel commandline that includes "graphics_subsystem_mode=limited" // Note: This is only used when booting with kernel commandline that includes "graphics_subsystem_mode=limited"

2
Kernel/Devices/GPU/VMWare/GraphicsAdapter.cpp
View file

@ -28,7 +28,7 @@ ErrorOr<bool> VMWareGraphicsAdapter::probe(PCI::DeviceIdentifier const& pci_devi
return id.vendor_id == PCI::VendorID::VMWare && id.device_id == 0x0405; return id.vendor_id == PCI::VendorID::VMWare && id.device_id == 0x0405;
} }
ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> VMWareGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) ErrorOr<NonnullLockRefPtr<GPUDevice>> VMWareGraphicsAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier)
{ {
auto registers_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0)); auto registers_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0));
auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) VMWareGraphicsAdapter(pci_device_identifier, move(registers_io_window)))); auto adapter = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) VMWareGraphicsAdapter(pci_device_identifier, move(registers_io_window))));

6
Kernel/Devices/GPU/VMWare/GraphicsAdapter.h
View file

@ -8,7 +8,7 @@
#include <AK/Types.h> #include <AK/Types.h>
#include <Kernel/Bus/PCI/Device.h> #include <Kernel/Bus/PCI/Device.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h> #include <Kernel/Devices/GPU/GPUDevice.h>
#include <Kernel/Devices/GPU/VMWare/Definitions.h> #include <Kernel/Devices/GPU/VMWare/Definitions.h>
#include <Kernel/Library/IOWindow.h> #include <Kernel/Library/IOWindow.h>
#include <Kernel/Locking/Spinlock.h> #include <Kernel/Locking/Spinlock.h>
@ -21,13 +21,13 @@ class GraphicsManagement;
class VMWareDisplayConnector; class VMWareDisplayConnector;
class VMWareGraphicsAdapter final class VMWareGraphicsAdapter final
: public GenericGraphicsAdapter : public GPUDevice
, public PCI::Device { , public PCI::Device {
friend class GraphicsManagement; friend class GraphicsManagement;
public: public:
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&); static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
static ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> create(PCI::DeviceIdentifier const&); static ErrorOr<NonnullLockRefPtr<GPUDevice>> create(PCI::DeviceIdentifier const&);
virtual ~VMWareGraphicsAdapter() = default; virtual ~VMWareGraphicsAdapter() = default;
virtual StringView device_name() const override { return "VMWareGraphicsAdapter"sv; } virtual StringView device_name() const override { return "VMWareGraphicsAdapter"sv; }

2
Kernel/Devices/GPU/VirtIO/GraphicsAdapter.cpp
View file

@ -28,7 +28,7 @@ ErrorOr<bool> VirtIOGraphicsAdapter::probe(PCI::DeviceIdentifier const& device_i
return device_identifier.hardware_id().vendor_id == PCI::VendorID::VirtIO; return device_identifier.hardware_id().vendor_id == PCI::VendorID::VirtIO;
} }
ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> VirtIOGraphicsAdapter::create(PCI::DeviceIdentifier const& device_identifier) ErrorOr<NonnullLockRefPtr<GPUDevice>> VirtIOGraphicsAdapter::create(PCI::DeviceIdentifier const& device_identifier)
{ {
// Setup memory transfer region // Setup memory transfer region
auto scratch_space_region = TRY(MM.allocate_contiguous_kernel_region( auto scratch_space_region = TRY(MM.allocate_contiguous_kernel_region(

6
Kernel/Devices/GPU/VirtIO/GraphicsAdapter.h
View file

@ -10,7 +10,7 @@
#include <AK/DistinctNumeric.h> #include <AK/DistinctNumeric.h>
#include <Kernel/Bus/VirtIO/Device.h> #include <Kernel/Bus/VirtIO/Device.h>
#include <Kernel/Bus/VirtIO/Queue.h> #include <Kernel/Bus/VirtIO/Queue.h>
#include <Kernel/Devices/GPU/GenericGraphicsAdapter.h> #include <Kernel/Devices/GPU/GPUDevice.h>
#include <Kernel/Devices/GPU/VirtIO/Protocol.h> #include <Kernel/Devices/GPU/VirtIO/Protocol.h>
namespace Kernel { namespace Kernel {
@ -31,14 +31,14 @@ namespace Kernel {
class VirtIODisplayConnector; class VirtIODisplayConnector;
class VirtIOGPU3DDevice; class VirtIOGPU3DDevice;
class VirtIOGraphicsAdapter final class VirtIOGraphicsAdapter final
: public GenericGraphicsAdapter : public GPUDevice
, public VirtIO::Device { , public VirtIO::Device {
friend class VirtIODisplayConnector; friend class VirtIODisplayConnector;
friend class VirtIOGPU3DDevice; friend class VirtIOGPU3DDevice;
public: public:
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&); static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
static ErrorOr<NonnullLockRefPtr<GenericGraphicsAdapter>> create(PCI::DeviceIdentifier const&); static ErrorOr<NonnullLockRefPtr<GPUDevice>> create(PCI::DeviceIdentifier const&);
virtual ErrorOr<void> initialize_virtio_resources() override; virtual ErrorOr<void> initialize_virtio_resources() override;