mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 09:48:11 +00:00
1f9d3a3523
There are now 2 separate classes for almost the same object type: - EnumerableDeviceIdentifier, which is used in the enumeration code for all PCI host controller classes. This is allowed to be moved and copied, as it doesn't support ref-counting. - DeviceIdentifier, which inherits from EnumerableDeviceIdentifier. This class uses ref-counting, and is not allowed to be copied. It has a spinlock member in its structure to allow safely executing complicated IO sequences on a PCI device and its space configuration. There's a static method that allows a quick conversion from EnumerableDeviceIdentifier to DeviceIdentifier while creating a NonnullRefPtr out of it. The reason for doing this is for the sake of integrity and reliablity of the system in 2 places: - Ensure that "complicated" tasks that rely on manipulating PCI device registers are done in a safe manner. For example, determining a PCI BAR space size requires multiple read and writes to the same register, and if another CPU tries to do something else with our selected register, then the result will be a catastrophe. - Allow the PCI API to have a united form around a shared object which actually holds much more data than the PCI::Address structure. This is fundamental if we want to do certain types of optimizations, and be able to support more features of the PCI bus in the foreseeable future. This patch already has several implications: - All PCI::Device(s) hold a reference to a DeviceIdentifier structure being given originally from the PCI::Access singleton. This means that all instances of DeviceIdentifier structures are located in one place, and all references are pointing to that location. This ensures that locking the operation spinlock will take effect in all the appropriate places. - We no longer support adding PCI host controllers and then immediately allow for enumerating it with a lambda function. It was found that this method is extremely broken and too much complicated to work reliably with the new paradigm being introduced in this patch. This means that for Volume Management Devices (Intel VMD devices), we simply first enumerate the PCI bus for such devices in the storage code, and if we find a device, we attach it in the PCI::Access method which will scan for devices behind that bridge and will add new DeviceIdentifier(s) objects to its internal Vector. Afterwards, we just continue as usual with scanning for actual storage controllers, so we will find a corresponding NVMe controllers if there were any behind that VMD bridge.
108 lines
3.5 KiB
C++
108 lines
3.5 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/OwnPtr.h>
|
|
#include <Kernel/Bus/PCI/Access.h>
|
|
#include <Kernel/Bus/PCI/Device.h>
|
|
#include <Kernel/IOWindow.h>
|
|
#include <Kernel/Interrupts/IRQHandler.h>
|
|
#include <Kernel/Net/NetworkAdapter.h>
|
|
#include <Kernel/Random.h>
|
|
|
|
namespace Kernel {
|
|
|
|
class E1000NetworkAdapter : public NetworkAdapter
|
|
, public PCI::Device
|
|
, public IRQHandler {
|
|
public:
|
|
static ErrorOr<bool> probe(PCI::DeviceIdentifier const&);
|
|
static ErrorOr<NonnullLockRefPtr<NetworkAdapter>> create(PCI::DeviceIdentifier const&);
|
|
virtual ErrorOr<void> initialize(Badge<NetworkingManagement>) override;
|
|
|
|
virtual ~E1000NetworkAdapter() override;
|
|
|
|
virtual void send_raw(ReadonlyBytes) override;
|
|
virtual bool link_up() override { return m_link_up; };
|
|
virtual i32 link_speed() override;
|
|
virtual bool link_full_duplex() override;
|
|
|
|
virtual StringView purpose() const override { return class_name(); }
|
|
virtual StringView device_name() const override { return "E1000"sv; }
|
|
virtual Type adapter_type() const override { return Type::Ethernet; }
|
|
|
|
protected:
|
|
static constexpr size_t rx_buffer_size = 8192;
|
|
static constexpr size_t tx_buffer_size = 8192;
|
|
|
|
void setup_interrupts();
|
|
void setup_link();
|
|
|
|
E1000NetworkAdapter(PCI::DeviceIdentifier const&, u8 irq,
|
|
NonnullOwnPtr<IOWindow> registers_io_window, NonnullOwnPtr<Memory::Region> rx_buffer_region,
|
|
NonnullOwnPtr<Memory::Region> tx_buffer_region, NonnullOwnPtr<Memory::Region> rx_descriptors_region,
|
|
NonnullOwnPtr<Memory::Region> tx_descriptors_region, NonnullOwnPtr<KString>);
|
|
|
|
virtual bool handle_irq(RegisterState const&) override;
|
|
virtual StringView class_name() const override { return "E1000NetworkAdapter"sv; }
|
|
|
|
struct [[gnu::packed]] e1000_rx_desc {
|
|
volatile uint64_t addr { 0 };
|
|
volatile uint16_t length { 0 };
|
|
volatile uint16_t checksum { 0 };
|
|
volatile uint8_t status { 0 };
|
|
volatile uint8_t errors { 0 };
|
|
volatile uint16_t special { 0 };
|
|
};
|
|
|
|
struct [[gnu::packed]] e1000_tx_desc {
|
|
volatile uint64_t addr { 0 };
|
|
volatile uint16_t length { 0 };
|
|
volatile uint8_t cso { 0 };
|
|
volatile uint8_t cmd { 0 };
|
|
volatile uint8_t status { 0 };
|
|
volatile uint8_t css { 0 };
|
|
volatile uint16_t special { 0 };
|
|
};
|
|
|
|
virtual void detect_eeprom();
|
|
virtual u32 read_eeprom(u8 address);
|
|
void read_mac_address();
|
|
|
|
void write_command(u16 address, u32);
|
|
u32 read_command(u16 address);
|
|
|
|
void initialize_rx_descriptors();
|
|
void initialize_tx_descriptors();
|
|
|
|
void out8(u16 address, u8);
|
|
void out16(u16 address, u16);
|
|
void out32(u16 address, u32);
|
|
u8 in8(u16 address);
|
|
u16 in16(u16 address);
|
|
u32 in32(u16 address);
|
|
|
|
void receive();
|
|
|
|
static constexpr size_t number_of_rx_descriptors = 256;
|
|
static constexpr size_t number_of_tx_descriptors = 256;
|
|
|
|
NonnullOwnPtr<IOWindow> m_registers_io_window;
|
|
|
|
NonnullOwnPtr<Memory::Region> m_rx_descriptors_region;
|
|
NonnullOwnPtr<Memory::Region> m_tx_descriptors_region;
|
|
NonnullOwnPtr<Memory::Region> m_rx_buffer_region;
|
|
NonnullOwnPtr<Memory::Region> m_tx_buffer_region;
|
|
Array<void*, number_of_rx_descriptors> m_rx_buffers;
|
|
Array<void*, number_of_tx_descriptors> m_tx_buffers;
|
|
bool m_has_eeprom { false };
|
|
bool m_link_up { false };
|
|
EntropySource m_entropy_source;
|
|
|
|
WaitQueue m_wait_queue;
|
|
};
|
|
}
|