diff --git a/Kernel/Arch/Interrupts.h b/Kernel/Arch/Interrupts.h index 9aacfa7a424..1bc818099b5 100644 --- a/Kernel/Arch/Interrupts.h +++ b/Kernel/Arch/Interrupts.h @@ -9,6 +9,7 @@ #include #include #include +#include #if ARCH(X86_64) # include @@ -20,10 +21,10 @@ namespace Kernel { class GenericInterruptHandler; -GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number); -void register_generic_interrupt_handler(u8 number, GenericInterruptHandler&); -void unregister_generic_interrupt_handler(u8 number, GenericInterruptHandler&); -ErrorOr reserve_interrupt_handlers(u8 number_of_irqs); +GenericInterruptHandler& get_interrupt_handler(InterruptNumber); +void register_generic_interrupt_handler(InterruptNumber, GenericInterruptHandler&); +void unregister_generic_interrupt_handler(InterruptNumber, GenericInterruptHandler&); +ErrorOr reserve_interrupt_handlers(size_t number_of_irqs); void initialize_interrupts(); diff --git a/Kernel/Arch/aarch64/IRQController.h b/Kernel/Arch/aarch64/IRQController.h index 7790fe561f9..bb47ac20cdb 100644 --- a/Kernel/Arch/aarch64/IRQController.h +++ b/Kernel/Arch/aarch64/IRQController.h @@ -8,6 +8,7 @@ #include #include +#include namespace Kernel { @@ -22,7 +23,7 @@ public: virtual void eoi(GenericInterruptHandler const&) = 0; - virtual Optional pending_interrupt() const = 0; + virtual Optional pending_interrupt() const = 0; virtual StringView model() const = 0; diff --git a/Kernel/Arch/aarch64/InterruptManagement.cpp b/Kernel/Arch/aarch64/InterruptManagement.cpp index a50202db3bf..774c7a787f3 100644 --- a/Kernel/Arch/aarch64/InterruptManagement.cpp +++ b/Kernel/Arch/aarch64/InterruptManagement.cpp @@ -43,7 +43,7 @@ ErrorOr InterruptManagement::register_interrupt_controller(NonnullLockRefP return s_interrupt_controllers->try_append(move(interrupt_controller)); } -u8 InterruptManagement::acquire_mapped_interrupt_number(u8 interrupt_number) +InterruptNumber InterruptManagement::acquire_mapped_interrupt_number(InterruptNumber interrupt_number) { return interrupt_number; } @@ -53,7 +53,7 @@ Vector> const& InterruptManagement::controllers return *s_interrupt_controllers; } -NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(u8) +NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(InterruptNumber) { // TODO: Support more interrupt controllers VERIFY(s_interrupt_controllers->size() == 1); diff --git a/Kernel/Arch/aarch64/InterruptManagement.h b/Kernel/Arch/aarch64/InterruptManagement.h index 4f1165645cf..58fd58c723b 100644 --- a/Kernel/Arch/aarch64/InterruptManagement.h +++ b/Kernel/Arch/aarch64/InterruptManagement.h @@ -20,10 +20,10 @@ public: static ErrorOr register_interrupt_controller(NonnullLockRefPtr); - static u8 acquire_mapped_interrupt_number(u8 original_irq); + static InterruptNumber acquire_mapped_interrupt_number(InterruptNumber original_irq); Vector> const& controllers(); - NonnullLockRefPtr get_responsible_irq_controller(u8 interrupt_vector); + NonnullLockRefPtr get_responsible_irq_controller(InterruptNumber interrupt_vector); void enumerate_interrupt_handlers(Function); diff --git a/Kernel/Arch/aarch64/Interrupts.cpp b/Kernel/Arch/aarch64/Interrupts.cpp index aa5bc74454d..4ae2e302525 100644 --- a/Kernel/Arch/aarch64/Interrupts.cpp +++ b/Kernel/Arch/aarch64/Interrupts.cpp @@ -162,7 +162,7 @@ extern "C" void handle_interrupt(TrapFrame& trap_frame) if (!maybe_irq.has_value()) break; - auto* handler = s_interrupt_handlers[maybe_irq.value()]; + auto* handler = s_interrupt_handlers[maybe_irq.value().value()]; VERIFY(handler); handler->increment_call_count(); handler->handle_interrupt(); @@ -175,22 +175,22 @@ extern "C" void handle_interrupt(TrapFrame& trap_frame) // FIXME: Share the code below with Arch/x86_64/Interrupts.cpp // While refactoring, the interrupt handlers can also be moved into the InterruptManagement class. -GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number) +GenericInterruptHandler& get_interrupt_handler(InterruptNumber interrupt_number) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; VERIFY(handler_slot != nullptr); return *handler_slot; } -static void revert_to_unused_handler(u8 interrupt_number) +static void revert_to_unused_handler(InterruptNumber interrupt_number) { auto handler = new UnhandledInterruptHandler(interrupt_number); handler->register_interrupt_handler(); } -void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void register_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; if (handler_slot == nullptr) { handler_slot = &handler; return; @@ -224,9 +224,9 @@ void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHan VERIFY_NOT_REACHED(); } -void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void unregister_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; VERIFY(handler_slot != nullptr); if (handler_slot->type() == HandlerType::UnhandledInterruptHandler) return; @@ -259,10 +259,10 @@ void initialize_interrupts() // Sets the reserved flag on `number_of_irqs` if it finds unused interrupt handler on // a contiguous range. // FIXME: Share the code below with Arch/x86_64/Interrupts.cpp. -ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) +ErrorOr reserve_interrupt_handlers(size_t number_of_irqs) { bool found_range = false; - u8 first_irq = 0; + InterruptNumber first_irq = 0; SpinlockLocker locker(s_interrupt_handler_lock); for (size_t start_irq = 0; start_irq < s_interrupt_handlers.size(); start_irq++) { auto*& handler_slot = s_interrupt_handlers[start_irq]; @@ -272,7 +272,7 @@ ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) continue; found_range = true; - for (auto off = 1; off < number_of_irqs; off++) { + for (size_t off = 1; off < number_of_irqs; off++) { auto*& handler = s_interrupt_handlers[start_irq + off]; VERIFY(handler_slot != nullptr); @@ -292,7 +292,7 @@ ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) return Error::from_errno(EAGAIN); for (auto irq = first_irq; irq < number_of_irqs; irq++) { - auto*& handler_slot = s_interrupt_handlers[irq]; + auto*& handler_slot = s_interrupt_handlers[irq.value()]; handler_slot->set_reserved(); } diff --git a/Kernel/Arch/aarch64/Interrupts/GICv2.cpp b/Kernel/Arch/aarch64/Interrupts/GICv2.cpp index c47c35ee412..93a30b349e7 100644 --- a/Kernel/Arch/aarch64/Interrupts/GICv2.cpp +++ b/Kernel/Arch/aarch64/Interrupts/GICv2.cpp @@ -106,22 +106,22 @@ void GICv2::enable(GenericInterruptHandler const& handler) // FIXME: Set the trigger mode in DistributorRegisters::interrupt_configuration (GICD_ICFGRn) to level-triggered or edge-triggered. auto interrupt_number = handler.interrupt_number(); - m_distributor_registers->interrupt_set_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_distributor_registers->interrupt_set_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); } void GICv2::disable(GenericInterruptHandler const& handler) { auto interrupt_number = handler.interrupt_number(); - m_distributor_registers->interrupt_clear_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_distributor_registers->interrupt_clear_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); } void GICv2::eoi(GenericInterruptHandler const& handler) { auto interrupt_number = handler.interrupt_number(); - m_cpu_interface_registers->end_of_interrupt = interrupt_number; + m_cpu_interface_registers->end_of_interrupt = interrupt_number.value(); } -Optional GICv2::pending_interrupt() const +Optional GICv2::pending_interrupt() const { auto interrupt_number = m_cpu_interface_registers->interrupt_acknowledge; @@ -132,7 +132,7 @@ Optional GICv2::pending_interrupt() const return interrupt_number; } -ErrorOr GICv2::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const +ErrorOr GICv2::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const { // https://www.kernel.org/doc/Documentation/devicetree/bindings/interrupt-controller/arm,gic.yaml diff --git a/Kernel/Arch/aarch64/Interrupts/GICv2.h b/Kernel/Arch/aarch64/Interrupts/GICv2.h index 834def173bb..fc3e420aa95 100644 --- a/Kernel/Arch/aarch64/Interrupts/GICv2.h +++ b/Kernel/Arch/aarch64/Interrupts/GICv2.h @@ -27,12 +27,12 @@ public: virtual void eoi(GenericInterruptHandler const&) override; - virtual Optional pending_interrupt() const override; + virtual Optional pending_interrupt() const override; virtual StringView model() const override { return "GICv2"sv; } // ^DeviceTree::InterruptController - virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; + virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; struct DistributorRegisters; struct CPUInterfaceRegisters; diff --git a/Kernel/Arch/aarch64/Interrupts/GICv3.cpp b/Kernel/Arch/aarch64/Interrupts/GICv3.cpp index cf0aed5de80..5b36fcc38bc 100644 --- a/Kernel/Arch/aarch64/Interrupts/GICv3.cpp +++ b/Kernel/Arch/aarch64/Interrupts/GICv3.cpp @@ -106,9 +106,9 @@ void GICv3::enable(GenericInterruptHandler const& handler) auto interrupt_number = handler.interrupt_number(); if (interrupt_number < SHARED_PERIPHERAL_INTERRUPT_RANGE_START) - m_redistributor_registers[m_boot_cpu_redistributor_index]->sgis_and_ppis.interrupt_set_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_redistributor_registers[m_boot_cpu_redistributor_index]->sgis_and_ppis.interrupt_set_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); else - m_distributor_registers->interrupt_set_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_distributor_registers->interrupt_set_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); } void GICv3::disable(GenericInterruptHandler const& handler) @@ -116,18 +116,18 @@ void GICv3::disable(GenericInterruptHandler const& handler) auto interrupt_number = handler.interrupt_number(); if (interrupt_number < SHARED_PERIPHERAL_INTERRUPT_RANGE_START) - m_redistributor_registers[m_boot_cpu_redistributor_index]->sgis_and_ppis.interrupt_clear_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_redistributor_registers[m_boot_cpu_redistributor_index]->sgis_and_ppis.interrupt_clear_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); else - m_distributor_registers->interrupt_clear_enable[interrupt_number / 32] = 1 << (interrupt_number % 32); + m_distributor_registers->interrupt_clear_enable[interrupt_number.value() / 32] = 1 << (interrupt_number.value() % 32); } void GICv3::eoi(GenericInterruptHandler const& handler) { auto interrupt_number = handler.interrupt_number(); - Aarch64::ICC_EOIR1_EL1::write({ .INTID = interrupt_number }); + Aarch64::ICC_EOIR1_EL1::write({ .INTID = interrupt_number.value() }); } -Optional GICv3::pending_interrupt() const +Optional GICv3::pending_interrupt() const { auto interrupt_number = Aarch64::ICC_IAR1_EL1::read().INTID; @@ -143,7 +143,7 @@ Optional GICv3::pending_interrupt() const return interrupt_number; } -ErrorOr GICv3::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const +ErrorOr GICv3::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const { // https://www.kernel.org/doc/Documentation/devicetree/bindings/interrupt-controller/arm,gic-v3.yaml diff --git a/Kernel/Arch/aarch64/Interrupts/GICv3.h b/Kernel/Arch/aarch64/Interrupts/GICv3.h index bc81b1a4f74..d01b9a0dfbf 100644 --- a/Kernel/Arch/aarch64/Interrupts/GICv3.h +++ b/Kernel/Arch/aarch64/Interrupts/GICv3.h @@ -28,12 +28,12 @@ public: virtual void eoi(GenericInterruptHandler const&) override; - virtual Optional pending_interrupt() const override; + virtual Optional pending_interrupt() const override; virtual StringView model() const override { return "GICv3"sv; } // ^DeviceTree::InterruptController - virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; + virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; struct DistributorRegisters; struct RedistributorRegisters; diff --git a/Kernel/Arch/aarch64/RPi/InterruptController.cpp b/Kernel/Arch/aarch64/RPi/InterruptController.cpp index 8d6e0435236..e6298483d0f 100644 --- a/Kernel/Arch/aarch64/RPi/InterruptController.cpp +++ b/Kernel/Arch/aarch64/RPi/InterruptController.cpp @@ -38,24 +38,24 @@ InterruptController::InterruptController(Memory::TypedMappingenable_irqs_1 = m_registers->enable_irqs_1 | (1 << interrupt_number); + m_registers->enable_irqs_1 = m_registers->enable_irqs_1 | (1 << interrupt_number.value()); else - m_registers->enable_irqs_2 = m_registers->enable_irqs_2 | (1 << (interrupt_number - 32)); + m_registers->enable_irqs_2 = m_registers->enable_irqs_2 | (1 << (interrupt_number.value() - 32)); } void InterruptController::disable(GenericInterruptHandler const& handler) { - u8 interrupt_number = handler.interrupt_number(); + InterruptNumber interrupt_number = handler.interrupt_number(); VERIFY(interrupt_number < 64); if (interrupt_number < 32) - m_registers->disable_irqs_1 = m_registers->disable_irqs_1 | (1 << interrupt_number); + m_registers->disable_irqs_1 = m_registers->disable_irqs_1 | (1 << interrupt_number.value()); else - m_registers->disable_irqs_2 = m_registers->disable_irqs_2 | (1 << (interrupt_number - 32)); + m_registers->disable_irqs_2 = m_registers->disable_irqs_2 | (1 << (interrupt_number.value() - 32)); } void InterruptController::eoi(GenericInterruptHandler const&) @@ -64,7 +64,7 @@ void InterruptController::eoi(GenericInterruptHandler const&) // The interrupt should be cleared by the corresponding device driver, such as a timer or uart. } -Optional InterruptController::pending_interrupt() const +Optional InterruptController::pending_interrupt() const { auto irq_number_plus_one = bit_scan_forward(((u64)m_registers->irq_pending_2 << 32) | (u64)m_registers->irq_pending_1); if (irq_number_plus_one == 0) @@ -72,7 +72,7 @@ Optional InterruptController::pending_interrupt() const return irq_number_plus_one - 1; } -ErrorOr InterruptController::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const +ErrorOr InterruptController::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const { // https://www.kernel.org/doc/Documentation/devicetree/bindings/interrupt-controller/brcm,bcm2835-armctrl-ic.txt diff --git a/Kernel/Arch/aarch64/RPi/InterruptController.h b/Kernel/Arch/aarch64/RPi/InterruptController.h index c92357831e6..bd0e0fc06a0 100644 --- a/Kernel/Arch/aarch64/RPi/InterruptController.h +++ b/Kernel/Arch/aarch64/RPi/InterruptController.h @@ -31,7 +31,7 @@ private: virtual void eoi(GenericInterruptHandler const&) override; - virtual Optional pending_interrupt() const override; + virtual Optional pending_interrupt() const override; virtual StringView model() const override { @@ -39,7 +39,7 @@ private: } // ^DeviceTree::InterruptController - virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; + virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; Memory::TypedMapping m_registers; }; diff --git a/Kernel/Arch/aarch64/RPi/RP1.cpp b/Kernel/Arch/aarch64/RPi/RP1.cpp index a1a01e16917..d7551cc5ae2 100644 --- a/Kernel/Arch/aarch64/RPi/RP1.cpp +++ b/Kernel/Arch/aarch64/RPi/RP1.cpp @@ -17,10 +17,10 @@ namespace Kernel::RPi { class RP1xHCIController final : public USB::xHCI::xHCIController { public: - static ErrorOr> try_to_initialize(PhysicalAddress, size_t index, size_t interrupt_number); + static ErrorOr> try_to_initialize(PhysicalAddress, size_t index, InterruptNumber interrupt_number); private: - RP1xHCIController(Memory::TypedMapping registers_mapping, size_t index, size_t interrupt_number); + RP1xHCIController(Memory::TypedMapping registers_mapping, size_t index, InterruptNumber interrupt_number); // ^xHCIController virtual bool using_message_signalled_interrupts() const override { return m_using_message_signalled_interrupts; } @@ -32,11 +32,11 @@ private: } size_t m_index { 0 }; - size_t m_interrupt_number { 0 }; + InterruptNumber m_interrupt_number { 0 }; bool m_using_message_signalled_interrupts { false }; }; -ErrorOr> RP1xHCIController::try_to_initialize(PhysicalAddress paddr, size_t index, size_t interrupt_number) +ErrorOr> RP1xHCIController::try_to_initialize(PhysicalAddress paddr, size_t index, InterruptNumber interrupt_number) { auto registers_mapping = TRY(Memory::map_typed_writable(paddr)); @@ -45,7 +45,7 @@ ErrorOr> RP1xHCIController::try_to_initiali return controller; } -UNMAP_AFTER_INIT RP1xHCIController::RP1xHCIController(Memory::TypedMapping registers_mapping, size_t index, size_t interrupt_number) +UNMAP_AFTER_INIT RP1xHCIController::RP1xHCIController(Memory::TypedMapping registers_mapping, size_t index, InterruptNumber interrupt_number) : xHCIController(move(registers_mapping)) , m_index(index) , m_interrupt_number(interrupt_number) diff --git a/Kernel/Arch/aarch64/RPi/Timer.cpp b/Kernel/Arch/aarch64/RPi/Timer.cpp index c1482d20149..c4a31d7af45 100644 --- a/Kernel/Arch/aarch64/RPi/Timer.cpp +++ b/Kernel/Arch/aarch64/RPi/Timer.cpp @@ -33,7 +33,7 @@ enum FlagBits { SystemTimerMatch3 = 1 << 3, }; -Timer::Timer(Memory::TypedMapping registers_mapping, size_t interrupt_number) +Timer::Timer(Memory::TypedMapping registers_mapping, InterruptNumber interrupt_number) : HardwareTimer(interrupt_number) , m_registers(move(registers_mapping)) { diff --git a/Kernel/Arch/aarch64/RPi/Timer.h b/Kernel/Arch/aarch64/RPi/Timer.h index 1bc5b6da083..3fe9b5025e2 100644 --- a/Kernel/Arch/aarch64/RPi/Timer.h +++ b/Kernel/Arch/aarch64/RPi/Timer.h @@ -19,7 +19,7 @@ struct TimerRegisters; class Timer final : public HardwareTimer { public: - Timer(Memory::TypedMapping, size_t interrupt_number); + Timer(Memory::TypedMapping, InterruptNumber interrupt_number); virtual ~Timer(); virtual HardwareTimerType timer_type() const override { return HardwareTimerType::RPiTimer; } diff --git a/Kernel/Arch/aarch64/Time/ARMv8Timer.cpp b/Kernel/Arch/aarch64/Time/ARMv8Timer.cpp index eff95cd8b0b..5f092145aa2 100644 --- a/Kernel/Arch/aarch64/Time/ARMv8Timer.cpp +++ b/Kernel/Arch/aarch64/Time/ARMv8Timer.cpp @@ -14,7 +14,7 @@ namespace Kernel { static ARMv8Timer* s_the = nullptr; -ARMv8Timer::ARMv8Timer(u8 interrupt_number, u32 frequency) +ARMv8Timer::ARMv8Timer(InterruptNumber interrupt_number, u32 frequency) : HardwareTimer(interrupt_number) , m_frequency(frequency) { @@ -23,7 +23,7 @@ ARMv8Timer::ARMv8Timer(u8 interrupt_number, u32 frequency) start_timer(m_interrupt_interval); } -ErrorOr> ARMv8Timer::initialize(u8 interrupt_number, u32 frequency) +ErrorOr> ARMv8Timer::initialize(InterruptNumber interrupt_number, u32 frequency) { auto timer = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) ARMv8Timer(interrupt_number, frequency))); diff --git a/Kernel/Arch/aarch64/Time/ARMv8Timer.h b/Kernel/Arch/aarch64/Time/ARMv8Timer.h index eea1dd14e86..1f63dc4ceab 100644 --- a/Kernel/Arch/aarch64/Time/ARMv8Timer.h +++ b/Kernel/Arch/aarch64/Time/ARMv8Timer.h @@ -17,7 +17,7 @@ namespace Kernel { class ARMv8Timer final : public HardwareTimer { public: - static ErrorOr> initialize(u8 interrupt_number, u32 frequency); + static ErrorOr> initialize(InterruptNumber interrupt_number, u32 frequency); static bool is_initialized(); static ARMv8Timer& the(); @@ -41,7 +41,7 @@ public: u64 update_time(u64& seconds_since_boot, u32& ticks_this_second, bool query_only); private: - ARMv8Timer(u8 interrupt_number, u32 frequency); + ARMv8Timer(InterruptNumber interrupt_number, u32 frequency); static u64 current_ticks(); static void start_timer(u32 delta); diff --git a/Kernel/Arch/riscv64/IRQController.h b/Kernel/Arch/riscv64/IRQController.h index e982e2f128b..9b3a167fda1 100644 --- a/Kernel/Arch/riscv64/IRQController.h +++ b/Kernel/Arch/riscv64/IRQController.h @@ -26,7 +26,7 @@ public: virtual void eoi(GenericInterruptHandler const&) = 0; - virtual Optional pending_interrupt() const = 0; + virtual Optional pending_interrupt() const = 0; virtual StringView model() const = 0; diff --git a/Kernel/Arch/riscv64/InterruptManagement.cpp b/Kernel/Arch/riscv64/InterruptManagement.cpp index 7c5633fe518..613c7387594 100644 --- a/Kernel/Arch/riscv64/InterruptManagement.cpp +++ b/Kernel/Arch/riscv64/InterruptManagement.cpp @@ -44,7 +44,7 @@ ErrorOr InterruptManagement::register_interrupt_controller(NonnullLockRefP return s_interrupt_controllers->try_append(move(interrupt_controller)); } -u8 InterruptManagement::acquire_mapped_interrupt_number(u8 original_irq) +InterruptNumber InterruptManagement::acquire_mapped_interrupt_number(InterruptNumber original_irq) { return original_irq; } @@ -54,7 +54,7 @@ Vector> const& InterruptManagement::controllers return *s_interrupt_controllers; } -NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(size_t) +NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(InterruptNumber) { // TODO: Support more interrupt controllers VERIFY(s_interrupt_controllers->size() == 1); diff --git a/Kernel/Arch/riscv64/InterruptManagement.h b/Kernel/Arch/riscv64/InterruptManagement.h index 2287c75291f..f828ed4225d 100644 --- a/Kernel/Arch/riscv64/InterruptManagement.h +++ b/Kernel/Arch/riscv64/InterruptManagement.h @@ -23,10 +23,10 @@ public: static ErrorOr register_interrupt_controller(NonnullLockRefPtr); - static u8 acquire_mapped_interrupt_number(u8 original_irq); + static InterruptNumber acquire_mapped_interrupt_number(InterruptNumber original_irq); Vector> const& controllers(); - NonnullLockRefPtr get_responsible_irq_controller(size_t irq_number); + NonnullLockRefPtr get_responsible_irq_controller(InterruptNumber irq_number); void enumerate_interrupt_handlers(Function); diff --git a/Kernel/Arch/riscv64/Interrupts.cpp b/Kernel/Arch/riscv64/Interrupts.cpp index b6c88ee9170..2ccc2c177d0 100644 --- a/Kernel/Arch/riscv64/Interrupts.cpp +++ b/Kernel/Arch/riscv64/Interrupts.cpp @@ -76,7 +76,7 @@ extern "C" void trap_handler(TrapFrame& trap_frame) if (!maybe_interrupt_number.has_value()) break; - auto* handler = s_interrupt_handlers[maybe_interrupt_number.value()]; + auto* handler = s_interrupt_handlers[maybe_interrupt_number.value().value()]; VERIFY(handler); handler->increment_call_count(); handler->handle_interrupt(); @@ -169,30 +169,30 @@ extern "C" void trap_handler(TrapFrame& trap_frame) // FIXME: Share the code below with Arch/x86_64/Interrupts.cpp // While refactoring, the interrupt handlers can also be moved into the InterruptManagement class. -GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number) +GenericInterruptHandler& get_interrupt_handler(InterruptNumber interrupt_number) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; VERIFY(handler_slot != nullptr); return *handler_slot; } // Sets the reserved flag on `number_of_irqs` if it finds unused interrupt handler on // a contiguous range. -ErrorOr reserve_interrupt_handlers(u8) +ErrorOr reserve_interrupt_handlers(size_t) { TODO_RISCV64(); } -static void revert_to_unused_handler(u8 interrupt_number) +static void revert_to_unused_handler(InterruptNumber interrupt_number) { auto* handler = new UnhandledInterruptHandler(interrupt_number); handler->register_interrupt_handler(); } // FIXME: Share the code below with Arch/{x86_64,aarch64}/Interrupts.cpp -void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void register_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; if (handler_slot == nullptr) { handler_slot = &handler; return; @@ -227,9 +227,9 @@ void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHan } // FIXME: Share the code below with Arch/{x86_64,aarch64}/Interrupts.cpp -void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void unregister_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { - auto*& handler_slot = s_interrupt_handlers[interrupt_number]; + auto*& handler_slot = s_interrupt_handlers[interrupt_number.value()]; VERIFY(handler_slot != nullptr); if (handler_slot->type() == HandlerType::UnhandledInterruptHandler) return; diff --git a/Kernel/Arch/riscv64/Interrupts/PLIC.cpp b/Kernel/Arch/riscv64/Interrupts/PLIC.cpp index 9a5b20372ea..84d3a746a88 100644 --- a/Kernel/Arch/riscv64/Interrupts/PLIC.cpp +++ b/Kernel/Arch/riscv64/Interrupts/PLIC.cpp @@ -18,7 +18,6 @@ UNMAP_AFTER_INIT PLIC::PLIC(Memory::TypedMapping registers , m_interrupt_count(interrupt_count) , m_boot_hart_supervisor_mode_context_id(boot_hart_supervisor_mode_context_id) { - VERIFY(m_interrupt_count < 256); // TODO: Serenity currently only supports up to 256 unique interrupts, but the PLIC supports up to 1024 initialize(); } @@ -42,22 +41,22 @@ void PLIC::enable(GenericInterruptHandler const& handler) { auto interrupt_number = handler.interrupt_number(); VERIFY(interrupt_number > 0); // Interrupt number 0 is reserved to mean no-interrupt - m_registers->interrupt_enable_bitmap[m_boot_hart_supervisor_mode_context_id][interrupt_number >> 5] |= 1u << (interrupt_number & 0x1F); + m_registers->interrupt_enable_bitmap[m_boot_hart_supervisor_mode_context_id][interrupt_number.value() >> 5] |= 1u << (interrupt_number.value() & 0x1F); } void PLIC::disable(GenericInterruptHandler const& handler) { auto interrupt_number = handler.interrupt_number(); VERIFY(interrupt_number > 0); // Interrupt number 0 is reserved to mean no-interrupt - m_registers->interrupt_enable_bitmap[m_boot_hart_supervisor_mode_context_id][interrupt_number >> 5] &= ~(1u << (interrupt_number & 0x1F)); + m_registers->interrupt_enable_bitmap[m_boot_hart_supervisor_mode_context_id][interrupt_number.value() >> 5] &= ~(1u << (interrupt_number.value() & 0x1F)); } void PLIC::eoi(GenericInterruptHandler const& handler) { - m_registers->contexts[m_boot_hart_supervisor_mode_context_id].claim_complete = handler.interrupt_number(); + m_registers->contexts[m_boot_hart_supervisor_mode_context_id].claim_complete = handler.interrupt_number().value(); } -Optional PLIC::pending_interrupt() const +Optional PLIC::pending_interrupt() const { auto interrupt_number = m_registers->contexts[m_boot_hart_supervisor_mode_context_id].claim_complete; @@ -68,7 +67,7 @@ Optional PLIC::pending_interrupt() const return interrupt_number; } -ErrorOr PLIC::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const +ErrorOr PLIC::translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes interrupt_specifier) const { // https://www.kernel.org/doc/Documentation/devicetree/bindings/interrupt-controller/sifive,plic-1.0.0.yaml // For generic PLICs the #interrupt-cells property should be 1 and the interrupt specifier should simply be the interrupt number. diff --git a/Kernel/Arch/riscv64/Interrupts/PLIC.h b/Kernel/Arch/riscv64/Interrupts/PLIC.h index a4bda635404..2923e5e3b36 100644 --- a/Kernel/Arch/riscv64/Interrupts/PLIC.h +++ b/Kernel/Arch/riscv64/Interrupts/PLIC.h @@ -37,12 +37,12 @@ public: virtual void eoi(GenericInterruptHandler const&) override; - virtual Optional pending_interrupt() const override; + virtual Optional pending_interrupt() const override; virtual StringView model() const override { return "PLIC"sv; } // ^DeviceTree::InterruptController - virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; + virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const override; private: void initialize(); diff --git a/Kernel/Arch/x86_64/IRQController.h b/Kernel/Arch/x86_64/IRQController.h index 64e969033c3..ae48e87095c 100644 --- a/Kernel/Arch/x86_64/IRQController.h +++ b/Kernel/Arch/x86_64/IRQController.h @@ -9,6 +9,7 @@ #include #include #include +#include namespace Kernel { @@ -26,7 +27,7 @@ public: virtual void enable(GenericInterruptHandler const&) = 0; virtual void disable(GenericInterruptHandler const&) = 0; virtual void hard_disable() { m_hard_disabled = true; } - virtual bool is_vector_enabled(u8 number) const = 0; + virtual bool is_vector_enabled(InterruptNumber) const = 0; virtual bool is_enabled() const = 0; bool is_hard_disabled() const { return m_hard_disabled; } virtual void eoi(GenericInterruptHandler const&) const = 0; diff --git a/Kernel/Arch/x86_64/ISABus/I8042Controller.cpp b/Kernel/Arch/x86_64/ISABus/I8042Controller.cpp index eb02b132680..03a054db96a 100644 --- a/Kernel/Arch/x86_64/ISABus/I8042Controller.cpp +++ b/Kernel/Arch/x86_64/ISABus/I8042Controller.cpp @@ -22,7 +22,7 @@ namespace Kernel { #define IRQ_FIRST_PORT 1 #define IRQ_SECOND_PORT 12 -UNMAP_AFTER_INIT ErrorOr> I8042ControllerIRQHandler::try_create(I8042Controller const& controller, u8 irq_number) +UNMAP_AFTER_INIT ErrorOr> I8042ControllerIRQHandler::try_create(I8042Controller const& controller, InterruptNumber irq_number) { return adopt_nonnull_own_or_enomem(new I8042ControllerIRQHandler(controller, irq_number)); } @@ -32,7 +32,7 @@ bool I8042ControllerIRQHandler::handle_irq() return m_controller->handle_irq({}, interrupt_number()); } -UNMAP_AFTER_INIT I8042ControllerIRQHandler::I8042ControllerIRQHandler(I8042Controller const& controller, u8 irq_number) +UNMAP_AFTER_INIT I8042ControllerIRQHandler::I8042ControllerIRQHandler(I8042Controller const& controller, InterruptNumber irq_number) : IRQHandler(irq_number) , m_controller(controller) { @@ -47,7 +47,7 @@ UNMAP_AFTER_INIT I8042Controller::I8042Controller() { } -bool I8042Controller::handle_irq(Badge, u8 irq_number) +bool I8042Controller::handle_irq(Badge, InterruptNumber irq_number) { // NOTE: The controller will read the data and call handle_byte_read_from_serial_input // for the appropriate device. diff --git a/Kernel/Arch/x86_64/ISABus/I8042Controller.h b/Kernel/Arch/x86_64/ISABus/I8042Controller.h index a4415ba775c..338db16f009 100644 --- a/Kernel/Arch/x86_64/ISABus/I8042Controller.h +++ b/Kernel/Arch/x86_64/ISABus/I8042Controller.h @@ -74,10 +74,10 @@ class I8042Controller; class I8042ControllerIRQHandler final : public IRQHandler { public: - static ErrorOr> try_create(I8042Controller const&, u8 irq_number); + static ErrorOr> try_create(I8042Controller const&, InterruptNumber irq_number); private: - I8042ControllerIRQHandler(I8042Controller const& controller, u8 irq_number); + I8042ControllerIRQHandler(I8042Controller const& controller, InterruptNumber irq_number); // ^IRQHandler virtual bool handle_irq() override; @@ -118,7 +118,7 @@ public: // Note: This function exists only for the initialization process of the controller bool check_existence_via_probing(Badge); - bool handle_irq(Badge, u8 irq_number); + bool handle_irq(Badge, InterruptNumber irq_number); private: I8042Controller(); diff --git a/Kernel/Arch/x86_64/InterruptManagement.cpp b/Kernel/Arch/x86_64/InterruptManagement.cpp index a205776015d..c19cb9286a7 100644 --- a/Kernel/Arch/x86_64/InterruptManagement.cpp +++ b/Kernel/Arch/x86_64/InterruptManagement.cpp @@ -67,7 +67,7 @@ IRQController& InterruptManagement::get_interrupt_controller(size_t index) return *m_interrupt_controllers[index]; } -u8 InterruptManagement::acquire_mapped_interrupt_number(u8 original_irq) +InterruptNumber InterruptManagement::acquire_mapped_interrupt_number(InterruptNumber original_irq) { if (!InterruptManagement::initialized()) { // This is necessary, because we install UnhandledInterruptHandlers before we actually initialize the Interrupt Management object... @@ -76,25 +76,25 @@ u8 InterruptManagement::acquire_mapped_interrupt_number(u8 original_irq) return InterruptManagement::the().get_mapped_interrupt_vector(original_irq); } -u8 InterruptManagement::acquire_irq_number(u8 mapped_interrupt_vector) +InterruptNumber InterruptManagement::acquire_irq_number(InterruptNumber mapped_interrupt_vector) { VERIFY(InterruptManagement::initialized()); return InterruptManagement::the().get_irq_vector(mapped_interrupt_vector); } -u8 InterruptManagement::get_mapped_interrupt_vector(u8 original_irq) +InterruptNumber InterruptManagement::get_mapped_interrupt_vector(InterruptNumber original_irq) { // FIXME: For SMP configuration (with IOAPICs) use a better routing scheme to make redirections more efficient. return original_irq; } -u8 InterruptManagement::get_irq_vector(u8 mapped_interrupt_vector) +InterruptNumber InterruptManagement::get_irq_vector(InterruptNumber mapped_interrupt_vector) { // FIXME: For SMP configuration (with IOAPICs) use a better routing scheme to make redirections more efficient. return mapped_interrupt_vector; } -NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(IRQControllerType controller_type, u8 interrupt_vector) +NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(IRQControllerType controller_type, InterruptNumber interrupt_vector) { for (auto& irq_controller : m_interrupt_controllers) { if (irq_controller->gsi_base() <= interrupt_vector && irq_controller->type() == controller_type) @@ -103,7 +103,7 @@ NonnullLockRefPtr InterruptManagement::get_responsible_irq_contro VERIFY_NOT_REACHED(); } -NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(u8 interrupt_vector) +NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(InterruptNumber interrupt_vector) { if (m_interrupt_controllers.size() == 1 && m_interrupt_controllers[0]->type() == IRQControllerType::i8259) { return m_interrupt_controllers[0]; diff --git a/Kernel/Arch/x86_64/InterruptManagement.h b/Kernel/Arch/x86_64/InterruptManagement.h index 96e55c3bf6f..e9f50d0bdd4 100644 --- a/Kernel/Arch/x86_64/InterruptManagement.h +++ b/Kernel/Arch/x86_64/InterruptManagement.h @@ -45,19 +45,19 @@ public: static InterruptManagement& the(); static void initialize(); static bool initialized(); - static u8 acquire_mapped_interrupt_number(u8 original_irq); - static u8 acquire_irq_number(u8 mapped_interrupt_vector); + static InterruptNumber acquire_mapped_interrupt_number(InterruptNumber original_irq); + static InterruptNumber acquire_irq_number(InterruptNumber mapped_interrupt_vector); void switch_to_pic_mode(); void switch_to_ioapic_mode(); - NonnullLockRefPtr get_responsible_irq_controller(u8 interrupt_vector); - NonnullLockRefPtr get_responsible_irq_controller(IRQControllerType controller_type, u8 interrupt_vector); + NonnullLockRefPtr get_responsible_irq_controller(InterruptNumber interrupt_vector); + NonnullLockRefPtr get_responsible_irq_controller(IRQControllerType controller_type, InterruptNumber interrupt_vector); Vector const& isa_overrides() const { return m_isa_interrupt_overrides; } - u8 get_mapped_interrupt_vector(u8 original_irq); - u8 get_irq_vector(u8 mapped_interrupt_vector); + InterruptNumber get_mapped_interrupt_vector(InterruptNumber original_irq); + InterruptNumber get_irq_vector(InterruptNumber mapped_interrupt_vector); void enumerate_interrupt_handlers(Function); IRQController& get_interrupt_controller(size_t index); diff --git a/Kernel/Arch/x86_64/Interrupts.cpp b/Kernel/Arch/x86_64/Interrupts.cpp index 5270b114d33..b69ea85fc20 100644 --- a/Kernel/Arch/x86_64/Interrupts.cpp +++ b/Kernel/Arch/x86_64/Interrupts.cpp @@ -301,7 +301,7 @@ void handle_interrupt(TrapFrame* trap) // reserved for when the PIC is disabled, so we can still route spurious // IRQs to a different interrupt handlers at different location. if (regs.isr_number >= pic_disabled_vector_base && regs.isr_number <= pic_disabled_vector_end) { - u8 irq = (u8)(regs.isr_number - pic_disabled_vector_base); + InterruptNumber irq = (InterruptNumber)(regs.isr_number - pic_disabled_vector_base); if (irq == 7) { handler = s_disabled_interrupt_handler[0]; } else if (irq == 15) { @@ -309,9 +309,9 @@ void handle_interrupt(TrapFrame* trap) } } else { VERIFY(regs.isr_number >= IRQ_VECTOR_BASE && regs.isr_number <= (IRQ_VECTOR_BASE + GENERIC_INTERRUPT_HANDLERS_COUNT)); - u8 irq = (u8)(regs.isr_number - IRQ_VECTOR_BASE); + InterruptNumber irq = (InterruptNumber)(regs.isr_number - IRQ_VECTOR_BASE); s_entropy_source_interrupts.add_random_event(irq); - handler = s_interrupt_handler[irq]; + handler = s_interrupt_handler[irq.value()]; } VERIFY(handler); handler->increment_call_count(); @@ -329,14 +329,14 @@ static void unimp_trap() PANIC("Unhandled IRQ"); } -GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number) +GenericInterruptHandler& get_interrupt_handler(InterruptNumber interrupt_number) { - auto*& handler_slot = s_interrupt_handler[interrupt_number]; + auto*& handler_slot = s_interrupt_handler[interrupt_number.value()]; VERIFY(handler_slot != nullptr); return *handler_slot; } -static void revert_to_unused_handler(u8 interrupt_number) +static void revert_to_unused_handler(InterruptNumber interrupt_number) { auto handler = new UnhandledInterruptHandler(interrupt_number); handler->register_interrupt_handler(); @@ -349,10 +349,10 @@ static bool is_unused_handler(GenericInterruptHandler* handler_slot) // Sets the reserved flag on `number_of_irqs` if it finds unused interrupt handler on // a contiguous range. -ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) +ErrorOr reserve_interrupt_handlers(size_t number_of_irqs) { bool found_range = false; - u8 first_irq = 0; + InterruptNumber first_irq = 0; SpinlockLocker locker(s_interrupt_handler_lock); for (int start_irq = 0; start_irq < GENERIC_INTERRUPT_HANDLERS_COUNT; start_irq++) { auto*& handler_slot = s_interrupt_handler[start_irq]; @@ -362,7 +362,7 @@ ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) continue; found_range = true; - for (auto off = 1; off < number_of_irqs; off++) { + for (size_t off = 1; off < number_of_irqs; off++) { auto*& handler = s_interrupt_handler[start_irq + off]; VERIFY(handler_slot != nullptr); @@ -382,14 +382,14 @@ ErrorOr reserve_interrupt_handlers(u8 number_of_irqs) return Error::from_errno(EAGAIN); for (auto irq = first_irq; irq < number_of_irqs; irq++) { - auto*& handler_slot = s_interrupt_handler[irq]; + auto*& handler_slot = s_interrupt_handler[irq.value()]; handler_slot->set_reserved(); } return first_irq; } -void register_disabled_interrupt_handler(u8 number, GenericInterruptHandler& handler) +void register_disabled_interrupt_handler(InterruptNumber number, GenericInterruptHandler& handler) { if (number == 15) { s_disabled_interrupt_handler[0] = &handler; @@ -401,10 +401,10 @@ void register_disabled_interrupt_handler(u8 number, GenericInterruptHandler& han VERIFY_NOT_REACHED(); } -void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void register_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { VERIFY(interrupt_number < GENERIC_INTERRUPT_HANDLERS_COUNT); - auto*& handler_slot = s_interrupt_handler[interrupt_number]; + auto*& handler_slot = s_interrupt_handler[interrupt_number.value()]; if (handler_slot == nullptr) { handler_slot = &handler; return; @@ -439,9 +439,9 @@ void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHan VERIFY_NOT_REACHED(); } -void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler) +void unregister_generic_interrupt_handler(InterruptNumber interrupt_number, GenericInterruptHandler& handler) { - auto*& handler_slot = s_interrupt_handler[interrupt_number]; + auto*& handler_slot = s_interrupt_handler[interrupt_number.value()]; VERIFY(handler_slot != nullptr); if (handler_slot->type() == HandlerType::UnhandledInterruptHandler) return; @@ -465,14 +465,14 @@ void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptH VERIFY_NOT_REACHED(); } -UNMAP_AFTER_INIT void register_interrupt_handler(u8 index, void (*handler)()) +UNMAP_AFTER_INIT void register_interrupt_handler(InterruptNumber index, void (*handler)()) { - s_idt[index] = IDTEntry((FlatPtr)handler, GDT_SELECTOR_CODE0, IDTEntryType::InterruptGate32, 0); + s_idt[index.value()] = IDTEntry((FlatPtr)handler, GDT_SELECTOR_CODE0, IDTEntryType::InterruptGate32, 0); } -UNMAP_AFTER_INIT void register_user_callable_interrupt_handler(u8 index, void (*handler)()) +UNMAP_AFTER_INIT void register_user_callable_interrupt_handler(InterruptNumber index, void (*handler)()) { - s_idt[index] = IDTEntry((FlatPtr)handler, GDT_SELECTOR_CODE0, IDTEntryType::TrapGate32, 3); + s_idt[index.value()] = IDTEntry((FlatPtr)handler, GDT_SELECTOR_CODE0, IDTEntryType::TrapGate32, 3); } UNMAP_AFTER_INIT void flush_idt() diff --git a/Kernel/Arch/x86_64/Interrupts.h b/Kernel/Arch/x86_64/Interrupts.h index 79d08614911..08de640d0b1 100644 --- a/Kernel/Arch/x86_64/Interrupts.h +++ b/Kernel/Arch/x86_64/Interrupts.h @@ -36,8 +36,8 @@ extern "C" void interrupt_common_asm_entry(); } // clang-format on -void register_interrupt_handler(u8 number, void (*handler)()); -void register_user_callable_interrupt_handler(u8 number, void (*handler)()); -void register_disabled_interrupt_handler(u8 number, GenericInterruptHandler& handler); +void register_interrupt_handler(InterruptNumber number, void (*handler)()); +void register_user_callable_interrupt_handler(InterruptNumber number, void (*handler)()); +void register_disabled_interrupt_handler(InterruptNumber number, GenericInterruptHandler& handler); } diff --git a/Kernel/Arch/x86_64/Interrupts/APIC.cpp b/Kernel/Arch/x86_64/Interrupts/APIC.cpp index be84a4e8bd1..bea772f264f 100644 --- a/Kernel/Arch/x86_64/Interrupts/APIC.cpp +++ b/Kernel/Arch/x86_64/Interrupts/APIC.cpp @@ -61,7 +61,7 @@ static Singleton s_apic; class APICIPIInterruptHandler final : public GenericInterruptHandler { public: - explicit APICIPIInterruptHandler(u8 interrupt_vector) + explicit APICIPIInterruptHandler(InterruptNumber interrupt_vector) : GenericInterruptHandler(interrupt_vector, true) { } @@ -69,7 +69,7 @@ public: { } - static void initialize(u8 interrupt_number) + static void initialize(InterruptNumber interrupt_number) { auto* handler = new APICIPIInterruptHandler(interrupt_number); handler->register_interrupt_handler(); @@ -91,7 +91,7 @@ private: class APICErrInterruptHandler final : public GenericInterruptHandler { public: - explicit APICErrInterruptHandler(u8 interrupt_vector) + explicit APICErrInterruptHandler(InterruptNumber interrupt_vector) : GenericInterruptHandler(interrupt_vector, true) { } @@ -99,7 +99,7 @@ public: { } - static void initialize(u8 interrupt_number) + static void initialize(InterruptNumber interrupt_number) { auto* handler = new APICErrInterruptHandler(interrupt_number); handler->register_interrupt_handler(); @@ -171,14 +171,14 @@ u32 APIC::read_register(u32 offset) return *reinterpret_cast(m_apic_base->vaddr().offset(offset).as_ptr()); } -void APIC::set_lvt(u32 offset, u8 interrupt) +void APIC::set_lvt(u32 offset, InterruptNumber interrupt) { - write_register(offset, read_register(offset) | interrupt); + write_register(offset, read_register(offset) | interrupt.value()); } -void APIC::set_siv(u32 offset, u8 interrupt) +void APIC::set_siv(u32 offset, InterruptNumber interrupt) { - write_register(offset, read_register(offset) | interrupt | APIC_ENABLED); + write_register(offset, read_register(offset) | interrupt.value() | APIC_ENABLED); } void APIC::wait_for_pending_icr() @@ -226,7 +226,7 @@ void APIC::eoi() write_register(APIC_REG_EOI, 0x0); } -u8 APIC::spurious_interrupt_vector() +InterruptNumber APIC::spurious_interrupt_vector() { return IRQ_APIC_SPURIOUS; } diff --git a/Kernel/Arch/x86_64/Interrupts/APIC.h b/Kernel/Arch/x86_64/Interrupts/APIC.h index fbfe0953064..6e40139bb46 100644 --- a/Kernel/Arch/x86_64/Interrupts/APIC.h +++ b/Kernel/Arch/x86_64/Interrupts/APIC.h @@ -33,7 +33,7 @@ public: void init_finished(u32 cpu); void broadcast_ipi(); void send_ipi(u32 cpu); - static u8 spurious_interrupt_vector(); + static InterruptNumber spurious_interrupt_vector(); Thread* get_idle_thread(u32 cpu) const; u32 enabled_processor_count() const { return m_processor_enabled_cnt; } @@ -106,8 +106,8 @@ private: void set_base(PhysicalAddress const& base); void write_register(u32 offset, u32 value); u32 read_register(u32 offset); - void set_lvt(u32 offset, u8 interrupt); - void set_siv(u32 offset, u8 interrupt); + void set_lvt(u32 offset, InterruptNumber interrupt); + void set_siv(u32 offset, InterruptNumber interrupt); void wait_for_pending_icr(); void write_icr(ICRReg const& icr); void do_boot_aps(); diff --git a/Kernel/Arch/x86_64/Interrupts/IOAPIC.cpp b/Kernel/Arch/x86_64/Interrupts/IOAPIC.cpp index bc944019d3b..471071bb7b6 100644 --- a/Kernel/Arch/x86_64/Interrupts/IOAPIC.cpp +++ b/Kernel/Arch/x86_64/Interrupts/IOAPIC.cpp @@ -43,7 +43,7 @@ UNMAP_AFTER_INIT void IOAPIC::initialize() { } -void IOAPIC::map_interrupt_redirection(u8 interrupt_vector) +void IOAPIC::map_interrupt_redirection(InterruptNumber interrupt_vector) { InterruptDisabler disabler; for (auto redirection_override : InterruptManagement::the().isa_overrides()) { @@ -85,7 +85,7 @@ void IOAPIC::map_interrupt_redirection(u8 interrupt_vector) configure_redirection_entry(redirection_override.gsi() - gsi_base(), InterruptManagement::acquire_mapped_interrupt_number(redirection_override.source()) + IRQ_VECTOR_BASE, DeliveryMode::Normal, false, active_low, trigger_level_mode, true, Processor::by_id(0).info().apic_id()); return; } - isa_identity_map(interrupt_vector); + isa_identity_map(interrupt_vector.value()); } void IOAPIC::isa_identity_map(size_t index) @@ -127,11 +127,11 @@ void IOAPIC::reset_redirection_entry(size_t index) const configure_redirection_entry(index, 0, 0, false, false, false, true, Processor::by_id(0).info().apic_id()); } -void IOAPIC::configure_redirection_entry(size_t index, u8 interrupt_vector, u8 delivery_mode, bool logical_destination, bool active_low, bool trigger_level_mode, bool masked, u8 destination) const +void IOAPIC::configure_redirection_entry(size_t index, InterruptNumber interrupt_vector, u8 delivery_mode, bool logical_destination, bool active_low, bool trigger_level_mode, bool masked, u8 destination) const { InterruptDisabler disabler; VERIFY(index < m_redirection_entries_count); - u32 redirection_entry1 = interrupt_vector | (delivery_mode & 0b111) << 8 | logical_destination << 11 | active_low << 13 | trigger_level_mode << 15 | masked << 16; + u32 redirection_entry1 = interrupt_vector.value() | (delivery_mode & 0b111) << 8 | logical_destination << 11 | active_low << 13 | trigger_level_mode << 15 | masked << 16; u32 redirection_entry2 = destination << 24; write_register((index << 1) + IOAPIC_REDIRECTION_ENTRY_OFFSET, redirection_entry1); @@ -175,10 +175,10 @@ void IOAPIC::unmask_redirection_entry(u8 index) const write_register((index << 1) + IOAPIC_REDIRECTION_ENTRY_OFFSET, redirection_entry & ~(1 << 16)); } -bool IOAPIC::is_vector_enabled(u8 interrupt_vector) const +bool IOAPIC::is_vector_enabled(InterruptNumber interrupt_vector) const { InterruptDisabler disabler; - return is_redirection_entry_masked(interrupt_vector); + return is_redirection_entry_masked(interrupt_vector.value()); } u8 IOAPIC::read_redirection_entry_vector(u8 index) const @@ -187,7 +187,7 @@ u8 IOAPIC::read_redirection_entry_vector(u8 index) const return (read_register((index << 1) + IOAPIC_REDIRECTION_ENTRY_OFFSET) & 0xFF); } -Optional IOAPIC::find_redirection_entry_by_vector(u8 vector) const +Optional IOAPIC::find_redirection_entry_by_vector(InterruptNumber vector) const { InterruptDisabler disabler; for (size_t index = 0; index < m_redirection_entries_count; index++) { @@ -201,7 +201,7 @@ void IOAPIC::disable(GenericInterruptHandler const& handler) { InterruptDisabler disabler; VERIFY(!is_hard_disabled()); - u8 interrupt_vector = handler.interrupt_number(); + InterruptNumber interrupt_vector = handler.interrupt_number(); VERIFY(interrupt_vector >= gsi_base() && interrupt_vector < interrupt_vectors_count()); auto found_index = find_redirection_entry_by_vector(interrupt_vector); if (!found_index.has_value()) { @@ -216,7 +216,7 @@ void IOAPIC::enable(GenericInterruptHandler const& handler) { InterruptDisabler disabler; VERIFY(!is_hard_disabled()); - u8 interrupt_vector = handler.interrupt_number(); + InterruptNumber interrupt_vector = handler.interrupt_number(); VERIFY(interrupt_vector >= gsi_base() && interrupt_vector < interrupt_vectors_count()); auto found_index = find_redirection_entry_by_vector(interrupt_vector); if (!found_index.has_value()) { diff --git a/Kernel/Arch/x86_64/Interrupts/IOAPIC.h b/Kernel/Arch/x86_64/Interrupts/IOAPIC.h index db1f5388a94..e5d27f8744f 100644 --- a/Kernel/Arch/x86_64/Interrupts/IOAPIC.h +++ b/Kernel/Arch/x86_64/Interrupts/IOAPIC.h @@ -18,7 +18,7 @@ struct [[gnu::packed]] ioapic_mmio_regs { class PCIInterruptOverrideMetadata { public: - PCIInterruptOverrideMetadata(u8 bus_id, u8 polarity, u8 trigger_mode, u8 source_irq, u32 ioapic_id, u16 ioapic_int_pin); + PCIInterruptOverrideMetadata(u8 bus_id, u8 polarity, u8 trigger_mode, InterruptNumber source_irq, u32 ioapic_id, u16 ioapic_int_pin); u8 bus() const { return m_bus_id; } u8 polarity() const { return m_polarity; } u8 trigger_mode() const { return m_trigger_mode; } @@ -45,7 +45,7 @@ public: virtual void hard_disable() override; virtual void eoi(GenericInterruptHandler const&) const override; virtual void spurious_eoi(GenericInterruptHandler const&) const override; - virtual bool is_vector_enabled(u8 number) const override; + virtual bool is_vector_enabled(InterruptNumber number) const override; virtual bool is_enabled() const override; virtual u16 get_isr() const override; virtual u16 get_irr() const override; @@ -55,9 +55,9 @@ public: virtual IRQControllerType type() const override { return IRQControllerType::i82093AA; } private: - void configure_redirection_entry(size_t index, u8 interrupt_vector, u8 delivery_mode, bool logical_destination, bool active_low, bool trigger_level_mode, bool masked, u8 destination) const; + void configure_redirection_entry(size_t index, InterruptNumber interrupt_vector, u8 delivery_mode, bool logical_destination, bool active_low, bool trigger_level_mode, bool masked, u8 destination) const; void reset_redirection_entry(size_t index) const; - void map_interrupt_redirection(u8 interrupt_vector); + void map_interrupt_redirection(InterruptNumber interrupt_vector); void reset_all_redirection_entries() const; void mask_all_redirection_entries() const; @@ -66,7 +66,7 @@ private: bool is_redirection_entry_masked(u8 index) const; u8 read_redirection_entry_vector(u8 index) const; - Optional find_redirection_entry_by_vector(u8 vector) const; + Optional find_redirection_entry_by_vector(InterruptNumber vector) const; void write_register(u32 index, u32 value) const; u32 read_register(u32 index) const; diff --git a/Kernel/Arch/x86_64/Interrupts/PIC.cpp b/Kernel/Arch/x86_64/Interrupts/PIC.cpp index 48c282c9322..0df005a56c5 100644 --- a/Kernel/Arch/x86_64/Interrupts/PIC.cpp +++ b/Kernel/Arch/x86_64/Interrupts/PIC.cpp @@ -50,20 +50,20 @@ void PIC::disable(GenericInterruptHandler const& handler) InterruptDisabler disabler; VERIFY(!is_hard_disabled()); VERIFY(handler.interrupt_number() >= gsi_base() && handler.interrupt_number() < interrupt_vectors_count()); - u8 irq = handler.interrupt_number(); - if (m_cached_irq_mask & (1 << irq)) + auto irq = handler.interrupt_number(); + if (m_cached_irq_mask & (1 << irq.value())) return; u8 imr; - if (irq & 8) { + if (irq.value() & 8) { imr = IO::in8(PIC1_CMD); - imr |= 1 << (irq & 7); + imr |= 1 << (irq.value() & 7); IO::out8(PIC1_CMD, imr); } else { imr = IO::in8(PIC0_CMD); - imr |= 1 << irq; + imr |= 1 << irq.value(); IO::out8(PIC0_CMD, imr); } - m_cached_irq_mask |= 1 << irq; + m_cached_irq_mask |= 1 << irq.value(); } UNMAP_AFTER_INIT PIC::PIC() @@ -82,9 +82,9 @@ void PIC::spurious_eoi(GenericInterruptHandler const& handler) const } } -bool PIC::is_vector_enabled(u8 irq) const +bool PIC::is_vector_enabled(InterruptNumber irq) const { - return m_cached_irq_mask & (1 << irq); + return m_cached_irq_mask & (1 << irq.value()); } void PIC::enable(GenericInterruptHandler const& handler) @@ -95,48 +95,48 @@ void PIC::enable(GenericInterruptHandler const& handler) enable_vector(handler.interrupt_number()); } -void PIC::enable_vector(u8 irq) +void PIC::enable_vector(InterruptNumber irq) { InterruptDisabler disabler; VERIFY(!is_hard_disabled()); - if (!(m_cached_irq_mask & (1 << irq))) + if (!(m_cached_irq_mask & (1 << irq.value()))) return; u8 imr; - if (irq & 8) { + if (irq.value() & 8) { imr = IO::in8(PIC1_CMD); - imr &= ~(1 << (irq & 7)); + imr &= ~(1 << (irq.value() & 7)); IO::out8(PIC1_CMD, imr); } else { imr = IO::in8(PIC0_CMD); - imr &= ~(1 << irq); + imr &= ~(1 << irq.value()); IO::out8(PIC0_CMD, imr); } - m_cached_irq_mask &= ~(1 << irq); + m_cached_irq_mask &= ~(1 << irq.value()); } void PIC::eoi(GenericInterruptHandler const& handler) const { InterruptDisabler disabler; VERIFY(!is_hard_disabled()); - u8 irq = handler.interrupt_number(); + auto irq = handler.interrupt_number(); VERIFY(irq >= gsi_base() && irq < interrupt_vectors_count()); - if ((1 << irq) & m_cached_irq_mask) { + if ((1 << irq.value()) & m_cached_irq_mask) { spurious_eoi(handler); return; } eoi_interrupt(irq); } -void PIC::eoi_interrupt(u8 irq) const +void PIC::eoi_interrupt(InterruptNumber irq) const { - if (irq & 8) { + if (irq.value() & 8) { IO::in8(PIC1_CMD); /* dummy read */ - IO::out8(PIC1_CTL, 0x60 | (irq & 7)); + IO::out8(PIC1_CTL, 0x60 | (irq.value() & 7)); IO::out8(PIC0_CTL, 0x60 | (2)); return; } IO::in8(PIC0_CMD); /* dummy read */ - IO::out8(PIC0_CTL, 0x60 | irq); + IO::out8(PIC0_CTL, 0x60 | irq.value()); } void PIC::complete_eoi() const diff --git a/Kernel/Arch/x86_64/Interrupts/PIC.h b/Kernel/Arch/x86_64/Interrupts/PIC.h index e88e72326fd..d9a06f31f0b 100644 --- a/Kernel/Arch/x86_64/Interrupts/PIC.h +++ b/Kernel/Arch/x86_64/Interrupts/PIC.h @@ -8,6 +8,7 @@ #include #include +#include namespace Kernel { @@ -21,7 +22,7 @@ public: virtual void disable(GenericInterruptHandler const&) override; virtual void hard_disable() override; virtual void eoi(GenericInterruptHandler const&) const override; - virtual bool is_vector_enabled(u8 number) const override; + virtual bool is_vector_enabled(InterruptNumber number) const override; virtual bool is_enabled() const override; virtual void spurious_eoi(GenericInterruptHandler const&) const override; virtual u16 get_isr() const override; @@ -33,8 +34,8 @@ public: private: u16 m_cached_irq_mask { 0xffff }; - void eoi_interrupt(u8 irq) const; - void enable_vector(u8 number); + void eoi_interrupt(InterruptNumber irq) const; + void enable_vector(InterruptNumber number); void remap(u8 offset); void complete_eoi() const; virtual void initialize() override; diff --git a/Kernel/Arch/x86_64/Time/APICTimer.cpp b/Kernel/Arch/x86_64/Time/APICTimer.cpp index fe4a3b5af72..4a12827454d 100644 --- a/Kernel/Arch/x86_64/Time/APICTimer.cpp +++ b/Kernel/Arch/x86_64/Time/APICTimer.cpp @@ -14,7 +14,7 @@ namespace Kernel { #define APIC_TIMER_MEASURE_CPU_CLOCK -UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(u8 interrupt_number, HardwareTimerBase& calibration_source) +UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(InterruptNumber interrupt_number, HardwareTimerBase& calibration_source) { auto timer = adopt_lock_ref(*new APICTimer(interrupt_number, nullptr)); timer->register_interrupt_handler(); @@ -24,7 +24,7 @@ UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(u8 interrupt_number, HardwareT return &timer.leak_ref(); } -UNMAP_AFTER_INIT APICTimer::APICTimer(u8 interrupt_number, Function callback) +UNMAP_AFTER_INIT APICTimer::APICTimer(InterruptNumber interrupt_number, Function callback) : HardwareTimer(interrupt_number, move(callback)) { disable_remap(); diff --git a/Kernel/Arch/x86_64/Time/APICTimer.h b/Kernel/Arch/x86_64/Time/APICTimer.h index 6499557d302..ca9673f48b4 100644 --- a/Kernel/Arch/x86_64/Time/APICTimer.h +++ b/Kernel/Arch/x86_64/Time/APICTimer.h @@ -15,7 +15,7 @@ namespace Kernel { class APICTimer final : public HardwareTimer { public: - static APICTimer* initialize(u8, HardwareTimerBase&); + static APICTimer* initialize(InterruptNumber, HardwareTimerBase&); virtual HardwareTimerType timer_type() const override { return HardwareTimerType::LocalAPICTimer; } virtual StringView model() const override { return "LocalAPIC"sv; } @@ -35,7 +35,7 @@ public: void disable_local_timer(); private: - explicit APICTimer(u8, Function); + explicit APICTimer(InterruptNumber, Function); bool calibrate(HardwareTimerBase&); diff --git a/Kernel/Arch/x86_64/Time/HPET.cpp b/Kernel/Arch/x86_64/Time/HPET.cpp index 91edf44533b..b9bd2c4569e 100644 --- a/Kernel/Arch/x86_64/Time/HPET.cpp +++ b/Kernel/Arch/x86_64/Time/HPET.cpp @@ -359,11 +359,11 @@ Vector HPET::capable_interrupt_numbers(u8 comparator_number) return capable_interrupts; } -void HPET::set_comparator_irq_vector(u8 comparator_number, u8 irq_vector) +void HPET::set_comparator_irq_vector(u8 comparator_number, InterruptNumber irq_vector) { VERIFY(comparator_number <= m_comparators.size()); auto& comparator_registers = registers().timers[comparator_number]; - comparator_registers.capabilities = comparator_registers.capabilities | (irq_vector << 9); + comparator_registers.capabilities = comparator_registers.capabilities | (irq_vector.value() << 9); } bool HPET::is_periodic_capable(u8 comparator_number) const diff --git a/Kernel/Arch/x86_64/Time/HPET.h b/Kernel/Arch/x86_64/Time/HPET.h index 5d2d3479640..f51f876aaf5 100644 --- a/Kernel/Arch/x86_64/Time/HPET.h +++ b/Kernel/Arch/x86_64/Time/HPET.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -35,7 +36,7 @@ public: void update_periodic_comparator_value(); void update_non_periodic_comparator_value(HPETComparator const& comparator); - void set_comparator_irq_vector(u8 comparator_number, u8 irq_vector); + void set_comparator_irq_vector(u8 comparator_number, InterruptNumber irq_vector); void enable_periodic_interrupt(HPETComparator const& comparator); void disable_periodic_interrupt(HPETComparator const& comparator); diff --git a/Kernel/Arch/x86_64/Time/HPETComparator.cpp b/Kernel/Arch/x86_64/Time/HPETComparator.cpp index de26950591a..7df92fa2846 100644 --- a/Kernel/Arch/x86_64/Time/HPETComparator.cpp +++ b/Kernel/Arch/x86_64/Time/HPETComparator.cpp @@ -13,14 +13,14 @@ namespace Kernel { -UNMAP_AFTER_INIT NonnullLockRefPtr HPETComparator::create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable) +UNMAP_AFTER_INIT NonnullLockRefPtr HPETComparator::create(u8 number, InterruptNumber irq, bool periodic_capable, bool is_64bit_capable) { auto timer = adopt_lock_ref(*new HPETComparator(number, irq, periodic_capable, is_64bit_capable)); timer->register_interrupt_handler(); return timer; } -UNMAP_AFTER_INIT HPETComparator::HPETComparator(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable) +UNMAP_AFTER_INIT HPETComparator::HPETComparator(u8 number, InterruptNumber irq, bool periodic_capable, bool is_64bit_capable) : HardwareTimer(irq) , m_periodic(false) , m_periodic_capable(periodic_capable) diff --git a/Kernel/Arch/x86_64/Time/HPETComparator.h b/Kernel/Arch/x86_64/Time/HPETComparator.h index cfb7cc5edd6..fcaf1c83a3f 100644 --- a/Kernel/Arch/x86_64/Time/HPETComparator.h +++ b/Kernel/Arch/x86_64/Time/HPETComparator.h @@ -16,7 +16,7 @@ class HPETComparator final : public HardwareTimer { friend class HPET; public: - static NonnullLockRefPtr create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable); + static NonnullLockRefPtr create(u8 number, InterruptNumber irq, bool periodic_capable, bool is_64bit_capable); virtual HardwareTimerType timer_type() const override { return HardwareTimerType::HighPrecisionEventTimer; } virtual StringView model() const override { return "HPET"sv; } @@ -42,7 +42,7 @@ public: private: void set_new_countdown(); virtual bool handle_irq() override; - HPETComparator(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable); + HPETComparator(u8 number, InterruptNumber irq, bool periodic_capable, bool is_64bit_capable); bool m_periodic : 1; bool m_periodic_capable : 1; bool m_enabled : 1; diff --git a/Kernel/Bus/I2C/Drivers/HID.cpp b/Kernel/Bus/I2C/Drivers/HID.cpp index 5911b8f9492..c2f170cf312 100644 --- a/Kernel/Bus/I2C/Drivers/HID.cpp +++ b/Kernel/Bus/I2C/Drivers/HID.cpp @@ -22,7 +22,7 @@ class TransportInterface final : public HID::TransportInterface , public IRQHandler { public: - static ErrorOr> create(I2C::Controller& i2c_controller, I2C::Address i2c_address, HIDDescriptor const& hid_descriptor, size_t interrupt_number) + static ErrorOr> create(I2C::Controller& i2c_controller, I2C::Address i2c_address, HIDDescriptor const& hid_descriptor, InterruptNumber interrupt_number) { auto input_report_buffer = TRY(ByteBuffer::create_zeroed(hid_descriptor.max_input_length)); return TRY(adopt_nonnull_own_or_enomem(new (nothrow) TransportInterface(i2c_controller, i2c_address, hid_descriptor.input_register, interrupt_number, move(input_report_buffer)))); @@ -91,7 +91,7 @@ public: } private: - TransportInterface(I2C::Controller& i2c_controller, I2C::Address i2c_address, u16 input_register_index, size_t interrupt_number, ByteBuffer input_report_buffer) + TransportInterface(I2C::Controller& i2c_controller, I2C::Address i2c_address, u16 input_register_index, InterruptNumber interrupt_number, ByteBuffer input_report_buffer) : IRQHandler(interrupt_number) , m_i2c_controller(i2c_controller) , m_i2c_address(i2c_address) diff --git a/Kernel/Bus/PCI/Controller/HostController.cpp b/Kernel/Bus/PCI/Controller/HostController.cpp index 98c116d696c..11e4282c997 100644 --- a/Kernel/Bus/PCI/Controller/HostController.cpp +++ b/Kernel/Bus/PCI/Controller/HostController.cpp @@ -350,7 +350,7 @@ void HostController::configure_attached_devices(PCIConfiguration& config) auto interrupt_number = config.masked_interrupt_mapping.get(masked_identifier); if (interrupt_number.has_value()) - write8_field(device_identifier.address().bus(), device_identifier.address().device(), device_identifier.address().function(), PCI::RegisterOffset::INTERRUPT_LINE, interrupt_number.value()); + write8_field(device_identifier.address().bus(), device_identifier.address().device(), device_identifier.address().function(), PCI::RegisterOffset::INTERRUPT_LINE, interrupt_number.value().value()); if (read8_field(device_identifier.address().bus(), device_identifier.address().device(), device_identifier.address().function(), PCI::RegisterOffset::CLASS) != PCI::ClassID::Bridge) return; diff --git a/Kernel/Bus/PCI/Controller/HostController.h b/Kernel/Bus/PCI/Controller/HostController.h index 18ca6baef51..8df8ea1375a 100644 --- a/Kernel/Bus/PCI/Controller/HostController.h +++ b/Kernel/Bus/PCI/Controller/HostController.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Kernel::PCI { @@ -70,7 +71,7 @@ struct PCIConfiguration { // The keys contains the bus, device & function at the same offsets as OpenFirmware PCI addresses, // with the least significant 8 bits being the interrupt pin. - HashMap masked_interrupt_mapping; + HashMap masked_interrupt_mapping; PCIInterruptSpecifier interrupt_mask; }; diff --git a/Kernel/Bus/PCI/Device.cpp b/Kernel/Bus/PCI/Device.cpp index 7ebfac23d5a..7a9e77046ec 100644 --- a/Kernel/Bus/PCI/Device.cpp +++ b/Kernel/Bus/PCI/Device.cpp @@ -92,7 +92,7 @@ PCI::InterruptType Device::get_interrupt_type() // is nothing left to do. The second parameter `msi` is used by the // driver to indicate its intent to use message signalled interrupts. // MSI(x) is preferred over MSI if the device supports both. -ErrorOr Device::reserve_irqs(u8 number_of_irqs, bool msi) +ErrorOr Device::reserve_irqs(size_t number_of_irqs, bool msi) { // Let us not allow partial allocation of IRQs for MSIx. if (msi && is_msix_capable()) { @@ -116,12 +116,11 @@ ErrorOr Device::reserve_irqs(u8 number_of_irqs, bool msi) return m_interrupt_range.m_type; } -PhysicalAddress Device::msix_table_entry_address(u8 irq) +PhysicalAddress Device::msix_table_entry_address(InterruptNumber irq) { - auto index = static_cast(irq) - m_interrupt_range.m_start_irq; + auto index = static_cast(irq.value()) - m_interrupt_range.m_start_irq.value(); VERIFY(index < m_interrupt_range.m_irq_count); - VERIFY(index >= 0); auto table_bar_paddr = PCI::get_bar_address(device_identifier(), static_cast(m_pci_identifier->get_msix_table_bar())).release_value_but_fixme_should_propagate_errors(); auto table_offset = m_pci_identifier->get_msix_table_offset(); @@ -133,14 +132,14 @@ PhysicalAddress Device::msix_table_entry_address(u8 irq) // mainly useful for MSI/MSIx based interrupt mechanism where the driver // needs to program. If the PCI device doesn't support MSIx interrupts, then // this function will just return the irq used for pin based interrupt. -ErrorOr Device::allocate_irq(u8 index) +ErrorOr Device::allocate_irq(size_t index) { - if (Checked::addition_would_overflow(m_interrupt_range.m_start_irq, index)) + if (Checked::addition_would_overflow(m_interrupt_range.m_start_irq.value(), index)) return Error::from_errno(EINVAL); if ((m_interrupt_range.m_type == InterruptType::MSIX) && is_msix_capable()) { - auto entry_ptr = TRY(Memory::map_typed_writable(msix_table_entry_address(index + m_interrupt_range.m_start_irq))); - entry_ptr->data = msi_data_register(m_interrupt_range.m_start_irq + index, false, false); + auto entry_ptr = TRY(Memory::map_typed_writable(msix_table_entry_address(index + m_interrupt_range.m_start_irq.value()))); + entry_ptr->data = msi_data_register(m_interrupt_range.m_start_irq.value() + index, false, false); // TODO: we map all the IRQs to cpu 0 by default. We could attach // cpu affinity in the future where specific LAPIC id could be used. u64 addr = msi_address_register(0, false, false); @@ -156,7 +155,7 @@ ErrorOr Device::allocate_irq(u8 index) if (index > 0) return Error::from_errno(EINVAL); - auto data = msi_data_register(m_interrupt_range.m_start_irq + index, false, false); + auto data = msi_data_register(m_interrupt_range.m_start_irq.value() + index, false, false); auto addr = msi_address_register(0, false, false); for (auto& capability : m_pci_identifier->capabilities()) { if (capability.id().value() == PCI::Capabilities::ID::MSI) { @@ -177,7 +176,7 @@ ErrorOr Device::allocate_irq(u8 index) return m_interrupt_range.m_start_irq; } -void Device::enable_interrupt(u8 irq) +void Device::enable_interrupt(InterruptNumber irq) { if ((m_interrupt_range.m_type == InterruptType::MSIX) && is_msix_capable()) { auto entry = Memory::map_typed_writable(PhysicalAddress(msix_table_entry_address(irq))); @@ -195,7 +194,7 @@ void Device::enable_interrupt(u8 irq) } } -void Device::disable_interrupt(u8 irq) +void Device::disable_interrupt(InterruptNumber irq) { if ((m_interrupt_range.m_type == InterruptType::MSIX) && is_msix_capable()) { auto entry = Memory::map_typed_writable(PhysicalAddress(msix_table_entry_address(irq))); diff --git a/Kernel/Bus/PCI/Device.h b/Kernel/Bus/PCI/Device.h index 9a234d8de28..67e086c8a2a 100644 --- a/Kernel/Bus/PCI/Device.h +++ b/Kernel/Bus/PCI/Device.h @@ -11,6 +11,7 @@ #include #include #include +#include namespace Kernel::PCI { @@ -21,8 +22,8 @@ enum class InterruptType { }; struct InterruptRange { - u8 m_start_irq { 0 }; - u8 m_irq_count { 0 }; + InterruptNumber m_start_irq { 0 }; + InterruptNumber m_irq_count { 0 }; InterruptType m_type { InterruptType::PIN }; }; @@ -52,17 +53,17 @@ public: void enable_extended_message_signalled_interrupts(); void disable_extended_message_signalled_interrupts(); - ErrorOr reserve_irqs(u8 number_of_irqs, bool msi); - ErrorOr allocate_irq(u8 index); + ErrorOr reserve_irqs(size_t number_of_irqs, bool msi); + ErrorOr allocate_irq(size_t index); PCI::InterruptType get_interrupt_type(); - void enable_interrupt(u8 irq); - void disable_interrupt(u8 irq); + void enable_interrupt(InterruptNumber irq); + void disable_interrupt(InterruptNumber irq); protected: explicit Device(DeviceIdentifier const& pci_identifier); private: - PhysicalAddress msix_table_entry_address(u8 irq); + PhysicalAddress msix_table_entry_address(InterruptNumber irq); private: NonnullRefPtr const m_pci_identifier; diff --git a/Kernel/Bus/PCI/DeviceTreeHelpers.cpp b/Kernel/Bus/PCI/DeviceTreeHelpers.cpp index 39011dcca89..8f9b4437cc8 100644 --- a/Kernel/Bus/PCI/DeviceTreeHelpers.cpp +++ b/Kernel/Bus/PCI/DeviceTreeHelpers.cpp @@ -82,7 +82,7 @@ ErrorOr configure_devicetree_host_controller(HostController& host_controll u64 pci_64bit_mmio_size = 0; FlatPtr pci_io_base = 0; u64 pci_io_size = 0; - HashMap masked_interrupt_mapping; + HashMap masked_interrupt_mapping; PCIInterruptSpecifier interrupt_mask; auto const& device_tree = DeviceTree::get(); diff --git a/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.cpp b/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.cpp index 19dd0808a10..4e1f33f22b7 100644 --- a/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.cpp +++ b/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.cpp @@ -13,7 +13,7 @@ namespace Kernel::USB::xHCI { -ErrorOr> DeviceTreexHCIController::try_to_initialize(DeviceTree::Device::Resource registers_resource, StringView node_name, size_t interrupt_number) +ErrorOr> DeviceTreexHCIController::try_to_initialize(DeviceTree::Device::Resource registers_resource, StringView node_name, InterruptNumber interrupt_number) { auto registers_mapping = TRY(Memory::map_typed(registers_resource.paddr, registers_resource.size, Memory::Region::Access::ReadWrite)); @@ -22,7 +22,7 @@ ErrorOr> DeviceTreexHCIController::t return controller; } -UNMAP_AFTER_INIT DeviceTreexHCIController::DeviceTreexHCIController(Memory::TypedMapping registers_mapping, StringView node_name, size_t interrupt_number) +UNMAP_AFTER_INIT DeviceTreexHCIController::DeviceTreexHCIController(Memory::TypedMapping registers_mapping, StringView node_name, InterruptNumber interrupt_number) : xHCIController(move(registers_mapping)) , m_node_name(node_name) , m_interrupt_number(interrupt_number) diff --git a/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.h b/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.h index 52479a48898..1129001c9ad 100644 --- a/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.h +++ b/Kernel/Bus/USB/xHCI/DeviceTreexHCIController.h @@ -13,10 +13,10 @@ namespace Kernel::USB::xHCI { class DeviceTreexHCIController final : public xHCIController { public: - static ErrorOr> try_to_initialize(DeviceTree::Device::Resource, StringView node_name, size_t interrupt_number); + static ErrorOr> try_to_initialize(DeviceTree::Device::Resource, StringView node_name, InterruptNumber interrupt_number); private: - DeviceTreexHCIController(Memory::TypedMapping registers_mapping, StringView node_name, size_t interrupt_number); + DeviceTreexHCIController(Memory::TypedMapping registers_mapping, StringView node_name, InterruptNumber interrupt_number); // ^xHCIController virtual bool using_message_signalled_interrupts() const override { return m_using_message_signalled_interrupts; } @@ -28,7 +28,7 @@ private: } StringView m_node_name; - size_t m_interrupt_number { 0 }; + InterruptNumber m_interrupt_number { 0 }; bool m_using_message_signalled_interrupts { false }; }; diff --git a/Kernel/Bus/USB/xHCI/xHCIInterrupter.cpp b/Kernel/Bus/USB/xHCI/xHCIInterrupter.cpp index 041df11dc5f..f0b108e473b 100644 --- a/Kernel/Bus/USB/xHCI/xHCIInterrupter.cpp +++ b/Kernel/Bus/USB/xHCI/xHCIInterrupter.cpp @@ -14,7 +14,7 @@ ErrorOr> xHCIPCIInterrupter::create(PCIxHCICon return TRY(adopt_nonnull_own_or_enomem(new (nothrow) xHCIPCIInterrupter(controller, interrupter_id, irq))); } -xHCIPCIInterrupter::xHCIPCIInterrupter(PCIxHCIController& controller, u16 interrupter_id, u16 irq) +xHCIPCIInterrupter::xHCIPCIInterrupter(PCIxHCIController& controller, u16 interrupter_id, InterruptNumber irq) : PCI::IRQHandler(controller, irq) , m_controller(controller) , m_interrupter_id(interrupter_id) @@ -28,12 +28,12 @@ bool xHCIPCIInterrupter::handle_irq() return true; } -ErrorOr> xHCIDeviceTreeInterrupter::create(DeviceTreexHCIController& controller, size_t irq, u16 interrupter_id) +ErrorOr> xHCIDeviceTreeInterrupter::create(DeviceTreexHCIController& controller, InterruptNumber irq, u16 interrupter_id) { return TRY(adopt_nonnull_own_or_enomem(new (nothrow) xHCIDeviceTreeInterrupter(controller, interrupter_id, irq))); } -xHCIDeviceTreeInterrupter::xHCIDeviceTreeInterrupter(DeviceTreexHCIController& controller, u16 interrupter_id, size_t irq) +xHCIDeviceTreeInterrupter::xHCIDeviceTreeInterrupter(DeviceTreexHCIController& controller, u16 interrupter_id, InterruptNumber irq) : IRQHandler(irq) , m_controller(controller) , m_interrupter_id(interrupter_id) diff --git a/Kernel/Bus/USB/xHCI/xHCIInterrupter.h b/Kernel/Bus/USB/xHCI/xHCIInterrupter.h index 961a9cfe537..c5056813445 100644 --- a/Kernel/Bus/USB/xHCI/xHCIInterrupter.h +++ b/Kernel/Bus/USB/xHCI/xHCIInterrupter.h @@ -22,7 +22,7 @@ public: virtual StringView purpose() const override { return "xHCI Interrupter"sv; } private: - xHCIPCIInterrupter(PCIxHCIController& controller, u16 interrupter_id, u16 irq); + xHCIPCIInterrupter(PCIxHCIController& controller, u16 interrupter_id, InterruptNumber irq); virtual bool handle_irq() override; @@ -32,12 +32,12 @@ private: class xHCIDeviceTreeInterrupter final : public IRQHandler { public: - static ErrorOr> create(DeviceTreexHCIController&, size_t irq, u16 interrupter_id); + static ErrorOr> create(DeviceTreexHCIController&, InterruptNumber irq, u16 interrupter_id); virtual StringView purpose() const override { return "xHCI Interrupter"sv; } private: - xHCIDeviceTreeInterrupter(DeviceTreexHCIController& controller, u16 interrupter_id, size_t irq); + xHCIDeviceTreeInterrupter(DeviceTreexHCIController& controller, u16 interrupter_id, InterruptNumber irq); virtual bool handle_irq() override; diff --git a/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.cpp b/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.cpp index 8eedc1ba018..b7e6eb51e09 100644 --- a/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.cpp +++ b/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.cpp @@ -8,12 +8,12 @@ namespace Kernel::VirtIO { -ErrorOr> PCIeTransportInterruptHandler::create(PCIeTransportLink& transport_link, VirtIO::Device& parent_device, u8 irq) +ErrorOr> PCIeTransportInterruptHandler::create(PCIeTransportLink& transport_link, VirtIO::Device& parent_device, InterruptNumber irq) { return TRY(adopt_nonnull_own_or_enomem(new (nothrow) PCIeTransportInterruptHandler(transport_link, parent_device, irq))); } -PCIeTransportInterruptHandler::PCIeTransportInterruptHandler(PCIeTransportLink& transport_link, VirtIO::Device& parent_device, u8 irq) +PCIeTransportInterruptHandler::PCIeTransportInterruptHandler(PCIeTransportLink& transport_link, VirtIO::Device& parent_device, InterruptNumber irq) : TransportInterruptHandler(parent_device) , PCI::IRQHandler(transport_link, irq) { diff --git a/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.h b/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.h index 90d5836cfda..92eda458715 100644 --- a/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.h +++ b/Kernel/Bus/VirtIO/Transport/PCIe/InterruptHandler.h @@ -17,13 +17,13 @@ class PCIeTransportInterruptHandler final : public TransportInterruptHandler , public PCI::IRQHandler { public: - static ErrorOr> create(PCIeTransportLink&, VirtIO::Device&, u8 irq); + static ErrorOr> create(PCIeTransportLink&, VirtIO::Device&, InterruptNumber irq); virtual ~PCIeTransportInterruptHandler() override = default; virtual StringView purpose() const override { return "VirtIO PCI IRQ Handler"sv; } private: - PCIeTransportInterruptHandler(PCIeTransportLink&, VirtIO::Device&, u8 irq); + PCIeTransportInterruptHandler(PCIeTransportLink&, VirtIO::Device&, InterruptNumber irq); //^ IRQHandler virtual bool handle_irq() override; diff --git a/Kernel/Devices/Storage/AHCI/InterruptHandler.cpp b/Kernel/Devices/Storage/AHCI/InterruptHandler.cpp index db0b499af02..95a7da1f58b 100644 --- a/Kernel/Devices/Storage/AHCI/InterruptHandler.cpp +++ b/Kernel/Devices/Storage/AHCI/InterruptHandler.cpp @@ -8,7 +8,7 @@ namespace Kernel { -UNMAP_AFTER_INIT ErrorOr> AHCIInterruptHandler::create(AHCIController& controller, u8 irq, AHCI::MaskedBitField taken_ports) +UNMAP_AFTER_INIT ErrorOr> AHCIInterruptHandler::create(AHCIController& controller, InterruptNumber irq, AHCI::MaskedBitField taken_ports) { auto port_handler = TRY(adopt_nonnull_own_or_enomem(new (nothrow) AHCIInterruptHandler(controller, irq, taken_ports))); port_handler->allocate_resources_and_initialize_ports(); @@ -22,7 +22,7 @@ void AHCIInterruptHandler::allocate_resources_and_initialize_ports() enable_irq(); } -UNMAP_AFTER_INIT AHCIInterruptHandler::AHCIInterruptHandler(AHCIController& controller, u8 irq, AHCI::MaskedBitField taken_ports) +UNMAP_AFTER_INIT AHCIInterruptHandler::AHCIInterruptHandler(AHCIController& controller, InterruptNumber irq, AHCI::MaskedBitField taken_ports) : PCI::IRQHandler(controller, irq) , m_parent_controller(controller) , m_taken_ports(taken_ports) diff --git a/Kernel/Devices/Storage/AHCI/InterruptHandler.h b/Kernel/Devices/Storage/AHCI/InterruptHandler.h index 8cecb819743..c869b7232cd 100644 --- a/Kernel/Devices/Storage/AHCI/InterruptHandler.h +++ b/Kernel/Devices/Storage/AHCI/InterruptHandler.h @@ -28,7 +28,7 @@ class AHCIInterruptHandler final : public PCI::IRQHandler { friend class AHCIController; public: - static ErrorOr> create(AHCIController&, u8 irq, AHCI::MaskedBitField taken_ports); + static ErrorOr> create(AHCIController&, InterruptNumber irq, AHCI::MaskedBitField taken_ports); virtual ~AHCIInterruptHandler() override; virtual StringView purpose() const override { return "SATA IRQ Handler"sv; } @@ -36,7 +36,7 @@ public: bool is_responsible_for_port_index(u32 port_index) const { return m_taken_ports.is_set_at(port_index); } private: - AHCIInterruptHandler(AHCIController&, u8 irq, AHCI::MaskedBitField taken_ports); + AHCIInterruptHandler(AHCIController&, InterruptNumber irq, AHCI::MaskedBitField taken_ports); void allocate_resources_and_initialize_ports(); diff --git a/Kernel/Devices/Storage/NVMe/NVMeController.cpp b/Kernel/Devices/Storage/NVMe/NVMeController.cpp index e0265b428d0..6b15c0ce8bf 100644 --- a/Kernel/Devices/Storage/NVMe/NVMeController.cpp +++ b/Kernel/Devices/Storage/NVMe/NVMeController.cpp @@ -354,7 +354,7 @@ UNMAP_AFTER_INIT ErrorOr NVMeController::create_admin_queue(QueueType queu m_controller_regs->acq = reinterpret_cast(AK::convert_between_host_and_little_endian(cq_dma_pages.first()->paddr().as_ptr())); m_controller_regs->asq = reinterpret_cast(AK::convert_between_host_and_little_endian(sq_dma_pages.first()->paddr().as_ptr())); - Optional irq; + Optional irq; if (queue_type == QueueType::IRQ) irq = TRY(allocate_irq(0)); // Admin queue always uses the 0th index when using MSIx diff --git a/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.cpp b/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.cpp index 7227902fbee..73abd7a3293 100644 --- a/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.cpp +++ b/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.cpp @@ -11,14 +11,14 @@ namespace Kernel { -ErrorOr> NVMeInterruptQueue::try_create(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, u8 irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs) +ErrorOr> NVMeInterruptQueue::try_create(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, InterruptNumber irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs) { auto queue = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) NVMeInterruptQueue(device, move(rw_dma_region), rw_dma_page, qid, irq, q_depth, move(cq_dma_region), move(sq_dma_region), move(db_regs)))); queue->initialize_interrupt_queue(); return queue; } -UNMAP_AFTER_INIT NVMeInterruptQueue::NVMeInterruptQueue(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, u8 irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs) +UNMAP_AFTER_INIT NVMeInterruptQueue::NVMeInterruptQueue(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, InterruptNumber irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs) : NVMeQueue(move(rw_dma_region), rw_dma_page, qid, q_depth, move(cq_dma_region), move(sq_dma_region), move(db_regs)) , PCI::IRQHandler(device, irq) { diff --git a/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.h b/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.h index ba15d8be870..05cb0999240 100644 --- a/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.h +++ b/Kernel/Devices/Storage/NVMe/NVMeInterruptQueue.h @@ -14,14 +14,14 @@ namespace Kernel { class NVMeInterruptQueue : public NVMeQueue , public PCI::IRQHandler { public: - static ErrorOr> try_create(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, u8 irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs); + static ErrorOr> try_create(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, InterruptNumber irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs); void submit_sqe(NVMeSubmission& submission) override; virtual ~NVMeInterruptQueue() override = default; virtual StringView purpose() const override { return "NVMe"sv; } void initialize_interrupt_queue(); protected: - NVMeInterruptQueue(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, u8 irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs); + NVMeInterruptQueue(PCI::Device& device, NonnullOwnPtr rw_dma_region, NonnullRefPtr rw_dma_page, u16 qid, InterruptNumber irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs); private: virtual void complete_current_request(u16 cmdid, u16 status) override; diff --git a/Kernel/Devices/Storage/NVMe/NVMeQueue.cpp b/Kernel/Devices/Storage/NVMe/NVMeQueue.cpp index d07146c296c..15f0c26e46f 100644 --- a/Kernel/Devices/Storage/NVMe/NVMeQueue.cpp +++ b/Kernel/Devices/Storage/NVMe/NVMeQueue.cpp @@ -13,7 +13,7 @@ #include namespace Kernel { -ErrorOr> NVMeQueue::try_create(NVMeController& device, u16 qid, Optional irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs, QueueType queue_type) +ErrorOr> NVMeQueue::try_create(NVMeController& device, u16 qid, Optional irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs, QueueType queue_type) { // Note: Allocate DMA region for RW operation. For now the requests don't exceed more than 4096 bytes (Storage device takes care of it) RefPtr rw_dma_page; diff --git a/Kernel/Devices/Storage/NVMe/NVMeQueue.h b/Kernel/Devices/Storage/NVMe/NVMeQueue.h index 9896d925bd2..88088f30521 100644 --- a/Kernel/Devices/Storage/NVMe/NVMeQueue.h +++ b/Kernel/Devices/Storage/NVMe/NVMeQueue.h @@ -54,7 +54,7 @@ struct NVMeIO { class NVMeController; class NVMeQueue : public AtomicRefCounted { public: - static ErrorOr> try_create(NVMeController& device, u16 qid, Optional irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs, QueueType queue_type); + static ErrorOr> try_create(NVMeController& device, u16 qid, Optional irq, u32 q_depth, OwnPtr cq_dma_region, OwnPtr sq_dma_region, Doorbell db_regs, QueueType queue_type); bool is_admin_queue() { return m_admin_queue; } u16 submit_sync_sqe(NVMeSubmission&); void read(AsyncBlockDeviceRequest& request, u16 nsid, u64 index, u32 count); diff --git a/Kernel/FileSystem/SysFS/Subsystems/Kernel/Interrupts.cpp b/Kernel/FileSystem/SysFS/Subsystems/Kernel/Interrupts.cpp index 47e1d088a1e..1a32b2c830d 100644 --- a/Kernel/FileSystem/SysFS/Subsystems/Kernel/Interrupts.cpp +++ b/Kernel/FileSystem/SysFS/Subsystems/Kernel/Interrupts.cpp @@ -33,7 +33,7 @@ ErrorOr SysFSInterrupts::try_generate(KBufferBuilder& builder) result = ([&]() -> ErrorOr { auto obj = TRY(array.add_object()); TRY(obj.add("purpose"sv, handler.purpose())); - TRY(obj.add("interrupt_line"sv, handler.interrupt_number())); + TRY(obj.add("interrupt_line"sv, handler.interrupt_number().value())); TRY(obj.add("controller"sv, handler.controller())); TRY(obj.add("device_sharing"sv, (unsigned)handler.sharing_devices_count())); auto per_cpu_call_counts = TRY(obj.add_array("per_cpu_call_counts"sv)); diff --git a/Kernel/Firmware/ACPI/Initialize.cpp b/Kernel/Firmware/ACPI/Initialize.cpp index e6560f19462..88be33f8e3b 100644 --- a/Kernel/Firmware/ACPI/Initialize.cpp +++ b/Kernel/Firmware/ACPI/Initialize.cpp @@ -30,7 +30,7 @@ UNMAP_AFTER_INIT void initialize() auto facp_table_or_error = Memory::map_typed(facp.value()); if (facp_table_or_error.is_error()) return; - u8 irq_line = facp_table_or_error.value()->sci_int; + InterruptNumber irq_line = facp_table_or_error.value()->sci_int; Parser::must_initialize(rsdp.value(), facp.value(), irq_line); if (kernel_command_line().acpi_feature_level() == AcpiFeatureLevel::Enabled) diff --git a/Kernel/Firmware/ACPI/Parser.cpp b/Kernel/Firmware/ACPI/Parser.cpp index 71bff047119..450fd7c1b2f 100644 --- a/Kernel/Firmware/ACPI/Parser.cpp +++ b/Kernel/Firmware/ACPI/Parser.cpp @@ -31,7 +31,7 @@ Parser* Parser::the() return s_acpi_parser; } -void Parser::must_initialize(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number) +void Parser::must_initialize(PhysicalAddress rsdp, PhysicalAddress fadt, InterruptNumber irq_number) { VERIFY(!s_acpi_parser); s_acpi_parser = new (nothrow) Parser(rsdp, fadt, irq_number); @@ -394,7 +394,7 @@ UNMAP_AFTER_INIT void Parser::locate_main_system_description_table() } } -UNMAP_AFTER_INIT Parser::Parser(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number) +UNMAP_AFTER_INIT Parser::Parser(PhysicalAddress rsdp, PhysicalAddress fadt, InterruptNumber irq_number) : IRQHandler(irq_number) , m_rsdp(rsdp) , m_fadt(fadt) diff --git a/Kernel/Firmware/ACPI/Parser.h b/Kernel/Firmware/ACPI/Parser.h index 4bc4e15f183..35e236b5f45 100644 --- a/Kernel/Firmware/ACPI/Parser.h +++ b/Kernel/Firmware/ACPI/Parser.h @@ -52,7 +52,7 @@ class Parser final : public IRQHandler { public: static Parser* the(); - static void must_initialize(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number); + static void must_initialize(PhysicalAddress rsdp, PhysicalAddress fadt, InterruptNumber irq_number); virtual StringView purpose() const override { return "ACPI Parser"sv; } virtual bool handle_irq() override; @@ -83,7 +83,7 @@ public: ~Parser() = default; private: - Parser(PhysicalAddress rsdp, PhysicalAddress fadt, u8 irq_number); + Parser(PhysicalAddress rsdp, PhysicalAddress fadt, InterruptNumber irq_number); void locate_static_data(); void locate_main_system_description_table(); diff --git a/Kernel/Firmware/DeviceTree/Device.cpp b/Kernel/Firmware/DeviceTree/Device.cpp index ff8e88f1d11..779f6cd5c2f 100644 --- a/Kernel/Firmware/DeviceTree/Device.cpp +++ b/Kernel/Firmware/DeviceTree/Device.cpp @@ -19,7 +19,7 @@ ErrorOr Device::get_resource(size_t index) const }; } -ErrorOr Device::get_interrupt_number(size_t index) const +ErrorOr Device::get_interrupt_number(size_t index) const { auto interrupts = TRY(node().interrupts(DeviceTree::get())); auto maybe_interrupt = interrupts.get(index); diff --git a/Kernel/Firmware/DeviceTree/Device.h b/Kernel/Firmware/DeviceTree/Device.h index 55cbb246e1a..86b3206090d 100644 --- a/Kernel/Firmware/DeviceTree/Device.h +++ b/Kernel/Firmware/DeviceTree/Device.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -45,7 +46,7 @@ public: ErrorOr get_resource(size_t index) const; // FIXME: Add support for the "interrupt-names" property to resolve interrupts by name. - ErrorOr get_interrupt_number(size_t index) const; + ErrorOr get_interrupt_number(size_t index) const; private: ::DeviceTree::Node const& m_node; diff --git a/Kernel/Firmware/DeviceTree/InterruptController.h b/Kernel/Firmware/DeviceTree/InterruptController.h index c30378271b1..311140cc0d8 100644 --- a/Kernel/Firmware/DeviceTree/InterruptController.h +++ b/Kernel/Firmware/DeviceTree/InterruptController.h @@ -14,7 +14,7 @@ class InterruptController { public: virtual ~InterruptController() = default; - virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const = 0; + virtual ErrorOr translate_interrupt_specifier_to_interrupt_number(ReadonlyBytes) const = 0; }; } diff --git a/Kernel/Firmware/DeviceTree/Management.cpp b/Kernel/Firmware/DeviceTree/Management.cpp index d8a37beb270..aa02e52ddcc 100644 --- a/Kernel/Firmware/DeviceTree/Management.cpp +++ b/Kernel/Firmware/DeviceTree/Management.cpp @@ -45,7 +45,7 @@ ErrorOr Management::register_interrupt_controller(DeviceTree::Device const return {}; } -ErrorOr Management::resolve_interrupt_number(::DeviceTree::Interrupt interrupt) const +ErrorOr Management::resolve_interrupt_number(::DeviceTree::Interrupt interrupt) const { auto maybe_interrupt_controller = m_interrupt_controllers.get(interrupt.domain_root); if (!maybe_interrupt_controller.has_value()) diff --git a/Kernel/Firmware/DeviceTree/Management.h b/Kernel/Firmware/DeviceTree/Management.h index 579be7ddecf..5db324e8e16 100644 --- a/Kernel/Firmware/DeviceTree/Management.h +++ b/Kernel/Firmware/DeviceTree/Management.h @@ -9,6 +9,7 @@ #include #include #include +#include #include namespace Kernel::I2C { @@ -34,7 +35,7 @@ public: static ErrorOr i2c_controller_for(::DeviceTree::Node const&); - ErrorOr resolve_interrupt_number(::DeviceTree::Interrupt) const; + ErrorOr resolve_interrupt_number(::DeviceTree::Interrupt) const; ErrorOr scan_node_for_devices(::DeviceTree::Node const& node, ShouldProbeImmediately); diff --git a/Kernel/Interrupts/GenericInterruptHandler.cpp b/Kernel/Interrupts/GenericInterruptHandler.cpp index 530f60154ef..84d1985bd0a 100644 --- a/Kernel/Interrupts/GenericInterruptHandler.cpp +++ b/Kernel/Interrupts/GenericInterruptHandler.cpp @@ -10,12 +10,12 @@ #include namespace Kernel { -GenericInterruptHandler& GenericInterruptHandler::from(u8 interrupt_number) +GenericInterruptHandler& GenericInterruptHandler::from(InterruptNumber interrupt_number) { return get_interrupt_handler(interrupt_number); } -GenericInterruptHandler::GenericInterruptHandler(u8 interrupt_number, bool disable_remap) +GenericInterruptHandler::GenericInterruptHandler(InterruptNumber interrupt_number, bool disable_remap) : m_interrupt_number(interrupt_number) , m_disable_remap(disable_remap) { @@ -55,7 +55,7 @@ void GenericInterruptHandler::unregister_interrupt_handler() m_registered = false; } -void GenericInterruptHandler::change_interrupt_number(u8 number) +void GenericInterruptHandler::change_interrupt_number(InterruptNumber number) { VERIFY_INTERRUPTS_DISABLED(); VERIFY(!m_disable_remap); diff --git a/Kernel/Interrupts/GenericInterruptHandler.h b/Kernel/Interrupts/GenericInterruptHandler.h index 9b9cc96c239..9346784d28b 100644 --- a/Kernel/Interrupts/GenericInterruptHandler.h +++ b/Kernel/Interrupts/GenericInterruptHandler.h @@ -9,6 +9,7 @@ #include #include #include +#include namespace Kernel { @@ -21,7 +22,7 @@ enum class HandlerType : u8 { class GenericInterruptHandler { public: - static GenericInterruptHandler& from(u8 interrupt_number); + static GenericInterruptHandler& from(InterruptNumber interrupt_number); virtual ~GenericInterruptHandler() { VERIFY(!m_registered); @@ -35,7 +36,7 @@ public: void register_interrupt_handler(); void unregister_interrupt_handler(); - u8 interrupt_number() const { return m_interrupt_number; } + InterruptNumber interrupt_number() const { return m_interrupt_number; } ReadonlySpan per_cpu_call_counts() const; @@ -52,15 +53,15 @@ public: bool reserved() const { return m_reserved; } protected: - void change_interrupt_number(u8 number); - GenericInterruptHandler(u8 interrupt_number, bool disable_remap = false); + void change_interrupt_number(InterruptNumber number); + GenericInterruptHandler(InterruptNumber interrupt_number, bool disable_remap = false); void disable_remap() { m_disable_remap = true; } private: Array m_per_cpu_call_counts {}; - u8 m_interrupt_number { 0 }; + InterruptNumber m_interrupt_number { 0 }; bool m_disable_remap { false }; bool m_registered { false }; bool m_reserved { false }; diff --git a/Kernel/Interrupts/IRQHandler.cpp b/Kernel/Interrupts/IRQHandler.cpp index 8ea82011a83..08e38d6e92c 100644 --- a/Kernel/Interrupts/IRQHandler.cpp +++ b/Kernel/Interrupts/IRQHandler.cpp @@ -11,7 +11,7 @@ namespace Kernel { -IRQHandler::IRQHandler(u8 irq) +IRQHandler::IRQHandler(InterruptNumber irq) : GenericInterruptHandler(irq) , m_responsible_irq_controller(InterruptManagement::the().get_responsible_irq_controller(irq)) { @@ -49,7 +49,7 @@ void IRQHandler::disable_irq() m_responsible_irq_controller->disable(*this); } -void IRQHandler::change_irq_number(u8 irq) +void IRQHandler::change_irq_number(InterruptNumber irq) { InterruptDisabler disabler; change_interrupt_number(irq); diff --git a/Kernel/Interrupts/IRQHandler.h b/Kernel/Interrupts/IRQHandler.h index 6a0e2936c2a..ade2b0a5c9d 100644 --- a/Kernel/Interrupts/IRQHandler.h +++ b/Kernel/Interrupts/IRQHandler.h @@ -34,8 +34,8 @@ public: void set_shared_with_others(bool status) { m_shared_with_others = status; } protected: - void change_irq_number(u8 irq); - explicit IRQHandler(u8 irq); + void change_irq_number(InterruptNumber irq); + explicit IRQHandler(InterruptNumber irq); private: bool m_shared_with_others { false }; diff --git a/Kernel/Interrupts/Interrupts.h b/Kernel/Interrupts/Interrupts.h new file mode 100644 index 00000000000..96067fe444b --- /dev/null +++ b/Kernel/Interrupts/Interrupts.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2026, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include + +namespace Kernel { + +AK_TYPEDEF_DISTINCT_NUMERIC_GENERAL(size_t, InterruptNumber, Arithmetic, Comparison, Increment) + +} diff --git a/Kernel/Interrupts/PCIIRQHandler.cpp b/Kernel/Interrupts/PCIIRQHandler.cpp index f90b64aed45..4ca77c20e72 100644 --- a/Kernel/Interrupts/PCIIRQHandler.cpp +++ b/Kernel/Interrupts/PCIIRQHandler.cpp @@ -11,7 +11,7 @@ namespace Kernel::PCI { -IRQHandler::IRQHandler(PCI::Device& device, u8 irq) +IRQHandler::IRQHandler(PCI::Device& device, InterruptNumber irq) : GenericInterruptHandler(irq) , device(device) { diff --git a/Kernel/Interrupts/PCIIRQHandler.h b/Kernel/Interrupts/PCIIRQHandler.h index 453f31a9bb7..aaf822bbd56 100644 --- a/Kernel/Interrupts/PCIIRQHandler.h +++ b/Kernel/Interrupts/PCIIRQHandler.h @@ -35,7 +35,7 @@ public: void set_shared_with_others(bool status) { m_shared_with_others = status; } protected: - IRQHandler(PCI::Device& device, u8 irq); + IRQHandler(PCI::Device& device, InterruptNumber irq); private: bool m_shared_with_others { false }; diff --git a/Kernel/Interrupts/SharedIRQHandler.cpp b/Kernel/Interrupts/SharedIRQHandler.cpp index 6812c5a404a..ffd4bb228a1 100644 --- a/Kernel/Interrupts/SharedIRQHandler.cpp +++ b/Kernel/Interrupts/SharedIRQHandler.cpp @@ -13,7 +13,7 @@ namespace Kernel { -UNMAP_AFTER_INIT void SharedIRQHandler::initialize(u8 interrupt_number) +UNMAP_AFTER_INIT void SharedIRQHandler::initialize(InterruptNumber interrupt_number) { auto* handler = new SharedIRQHandler(interrupt_number); handler->register_interrupt_handler(); @@ -48,7 +48,7 @@ void SharedIRQHandler::enumerate_handlers(Function m_handlers; NonnullLockRefPtr m_responsible_irq_controller; diff --git a/Kernel/Interrupts/SpuriousInterruptHandler.cpp b/Kernel/Interrupts/SpuriousInterruptHandler.cpp index e15be1d6638..32d4da1ce0f 100644 --- a/Kernel/Interrupts/SpuriousInterruptHandler.cpp +++ b/Kernel/Interrupts/SpuriousInterruptHandler.cpp @@ -11,7 +11,7 @@ namespace Kernel { -UNMAP_AFTER_INIT void SpuriousInterruptHandler::initialize(u8 interrupt_number) +UNMAP_AFTER_INIT void SpuriousInterruptHandler::initialize(InterruptNumber interrupt_number) { auto* handler = new SpuriousInterruptHandler(interrupt_number); handler->register_interrupt_handler(); @@ -60,7 +60,7 @@ StringView SpuriousInterruptHandler::purpose() const return m_real_handler->purpose(); } -SpuriousInterruptHandler::SpuriousInterruptHandler(u8 irq) +SpuriousInterruptHandler::SpuriousInterruptHandler(InterruptNumber irq) : GenericInterruptHandler(irq) , m_responsible_irq_controller(InterruptManagement::the().get_responsible_irq_controller(irq)) { @@ -71,7 +71,7 @@ SpuriousInterruptHandler::~SpuriousInterruptHandler() = default; bool SpuriousInterruptHandler::handle_interrupt() { // Actually check if IRQ7 or IRQ15 are spurious, and if not, call the real handler to handle the IRQ. - if (m_responsible_irq_controller->get_isr() & (1 << interrupt_number())) { + if (m_responsible_irq_controller->get_isr() & (1 << interrupt_number().value())) { m_real_irq = true; // remember that we had a real IRQ, when EOI later! if (m_real_handler->handle_interrupt()) { m_real_handler->increment_call_count(); diff --git a/Kernel/Interrupts/SpuriousInterruptHandler.h b/Kernel/Interrupts/SpuriousInterruptHandler.h index 3ace709c515..9e455a1c2ff 100644 --- a/Kernel/Interrupts/SpuriousInterruptHandler.h +++ b/Kernel/Interrupts/SpuriousInterruptHandler.h @@ -15,7 +15,7 @@ namespace Kernel { class SpuriousInterruptHandler final : public GenericInterruptHandler { public: - static void initialize(u8 interrupt_number); + static void initialize(InterruptNumber interrupt_number); static void initialize_for_disabled_master_pic(); static void initialize_for_disabled_slave_pic(); virtual ~SpuriousInterruptHandler(); @@ -38,7 +38,7 @@ public: private: void enable_interrupt_vector(); void disable_interrupt_vector(); - explicit SpuriousInterruptHandler(u8 interrupt_number); + explicit SpuriousInterruptHandler(InterruptNumber interrupt_number); bool m_enabled { false }; bool m_real_irq { false }; NonnullLockRefPtr m_responsible_irq_controller; diff --git a/Kernel/Interrupts/UnhandledInterruptHandler.cpp b/Kernel/Interrupts/UnhandledInterruptHandler.cpp index 40f7d1e39c9..277f6a6b9f4 100644 --- a/Kernel/Interrupts/UnhandledInterruptHandler.cpp +++ b/Kernel/Interrupts/UnhandledInterruptHandler.cpp @@ -8,7 +8,7 @@ #include namespace Kernel { -UnhandledInterruptHandler::UnhandledInterruptHandler(u8 interrupt_vector) +UnhandledInterruptHandler::UnhandledInterruptHandler(InterruptNumber interrupt_vector) : GenericInterruptHandler(interrupt_vector) { } diff --git a/Kernel/Interrupts/UnhandledInterruptHandler.h b/Kernel/Interrupts/UnhandledInterruptHandler.h index 5e3781326af..39ea3a23e5f 100644 --- a/Kernel/Interrupts/UnhandledInterruptHandler.h +++ b/Kernel/Interrupts/UnhandledInterruptHandler.h @@ -12,7 +12,7 @@ namespace Kernel { class UnhandledInterruptHandler final : public GenericInterruptHandler { public: - explicit UnhandledInterruptHandler(u8 interrupt_vector); + explicit UnhandledInterruptHandler(InterruptNumber interrupt_vector); virtual ~UnhandledInterruptHandler(); virtual bool handle_interrupt() override; diff --git a/Kernel/Net/Intel/E1000ENetworkAdapter.cpp b/Kernel/Net/Intel/E1000ENetworkAdapter.cpp index 222c8b0d77b..58460320f7a 100644 --- a/Kernel/Net/Intel/E1000ENetworkAdapter.cpp +++ b/Kernel/Net/Intel/E1000ENetworkAdapter.cpp @@ -195,7 +195,7 @@ UNMAP_AFTER_INIT ErrorOr E1000ENetworkAdapter::probe(PCI::DeviceIdentifier UNMAP_AFTER_INIT ErrorOr> E1000ENetworkAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) { - u8 irq = pci_device_identifier.interrupt_line().value(); + InterruptNumber irq = pci_device_identifier.interrupt_line().value(); auto interface_name = TRY(NetworkingManagement::generate_interface_name_from_pci_address(pci_device_identifier)); auto registers_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0)); @@ -236,7 +236,7 @@ UNMAP_AFTER_INIT ErrorOr E1000ENetworkAdapter::initialize(Badge registers_io_window, NonnullOwnPtr rx_buffer_region, NonnullOwnPtr tx_buffer_region, Memory::TypedMapping rx_descriptors, Memory::TypedMapping tx_descriptors) diff --git a/Kernel/Net/Intel/E1000ENetworkAdapter.h b/Kernel/Net/Intel/E1000ENetworkAdapter.h index 59252ef26ac..e38e952a714 100644 --- a/Kernel/Net/Intel/E1000ENetworkAdapter.h +++ b/Kernel/Net/Intel/E1000ENetworkAdapter.h @@ -29,7 +29,7 @@ public: virtual StringView purpose() const override { return class_name(); } private: - E1000ENetworkAdapter(StringView interface_name, PCI::DeviceIdentifier const&, u8 irq, + E1000ENetworkAdapter(StringView interface_name, PCI::DeviceIdentifier const&, InterruptNumber irq, NonnullOwnPtr registers_io_window, NonnullOwnPtr rx_buffer_region, NonnullOwnPtr tx_buffer_region, Memory::TypedMapping rx_descriptors, Memory::TypedMapping tx_descriptors); diff --git a/Kernel/Net/Intel/E1000NetworkAdapter.cpp b/Kernel/Net/Intel/E1000NetworkAdapter.cpp index 7282bb4b53c..b10e678f48f 100644 --- a/Kernel/Net/Intel/E1000NetworkAdapter.cpp +++ b/Kernel/Net/Intel/E1000NetworkAdapter.cpp @@ -168,7 +168,7 @@ UNMAP_AFTER_INIT ErrorOr E1000NetworkAdapter::probe(PCI::DeviceIdentifier UNMAP_AFTER_INIT ErrorOr> E1000NetworkAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) { - u8 irq = pci_device_identifier.interrupt_line().value(); + InterruptNumber irq = pci_device_identifier.interrupt_line().value(); auto interface_name = TRY(NetworkingManagement::generate_interface_name_from_pci_address(pci_device_identifier)); auto registers_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0)); @@ -228,7 +228,7 @@ UNMAP_AFTER_INIT void E1000NetworkAdapter::setup_interrupts() } UNMAP_AFTER_INIT E1000NetworkAdapter::E1000NetworkAdapter(StringView interface_name, - PCI::DeviceIdentifier const& device_identifier, u8 irq, + PCI::DeviceIdentifier const& device_identifier, InterruptNumber irq, NonnullOwnPtr registers_io_window, NonnullOwnPtr rx_buffer_region, NonnullOwnPtr tx_buffer_region, Memory::TypedMapping rx_descriptors, Memory::TypedMapping tx_descriptors) diff --git a/Kernel/Net/Intel/E1000NetworkAdapter.h b/Kernel/Net/Intel/E1000NetworkAdapter.h index 9e6a184ea51..128c748f38b 100644 --- a/Kernel/Net/Intel/E1000NetworkAdapter.h +++ b/Kernel/Net/Intel/E1000NetworkAdapter.h @@ -64,7 +64,7 @@ protected: void setup_interrupts(); void setup_link(); - E1000NetworkAdapter(StringView, PCI::DeviceIdentifier const&, u8 irq, + E1000NetworkAdapter(StringView, PCI::DeviceIdentifier const&, InterruptNumber irq, NonnullOwnPtr registers_io_window, NonnullOwnPtr rx_buffer_region, NonnullOwnPtr tx_buffer_region, Memory::TypedMapping rx_descriptors, diff --git a/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp b/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp index 313313fb118..19ee6b96590 100644 --- a/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp +++ b/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp @@ -205,7 +205,7 @@ UNMAP_AFTER_INIT ErrorOr RTL8168NetworkAdapter::probe(PCI::DeviceIdentifie UNMAP_AFTER_INIT ErrorOr> RTL8168NetworkAdapter::create(PCI::DeviceIdentifier const& pci_device_identifier) { - u8 irq = pci_device_identifier.interrupt_line().value(); + InterruptNumber irq = pci_device_identifier.interrupt_line().value(); auto interface_name = TRY(NetworkingManagement::generate_interface_name_from_pci_address(pci_device_identifier)); auto registers_io_window = TRY(IOWindow::create_for_pci_device_bar(pci_device_identifier, PCI::HeaderType0BaseRegister::BAR0)); return TRY(adopt_nonnull_ref_or_enomem(new (nothrow) RTL8168NetworkAdapter(interface_name.representable_view(), pci_device_identifier, irq, move(registers_io_window)))); @@ -256,7 +256,7 @@ bool RTL8168NetworkAdapter::determine_supported_version() const } } -UNMAP_AFTER_INIT RTL8168NetworkAdapter::RTL8168NetworkAdapter(StringView interface_name, PCI::DeviceIdentifier const& device_identifier, u8 irq, NonnullOwnPtr registers_io_window) +UNMAP_AFTER_INIT RTL8168NetworkAdapter::RTL8168NetworkAdapter(StringView interface_name, PCI::DeviceIdentifier const& device_identifier, InterruptNumber irq, NonnullOwnPtr registers_io_window) : NetworkAdapter(interface_name) , PCI::Device(device_identifier) , IRQHandler(irq) diff --git a/Kernel/Net/Realtek/RTL8168NetworkAdapter.h b/Kernel/Net/Realtek/RTL8168NetworkAdapter.h index 88952c0041c..b920cc406d2 100644 --- a/Kernel/Net/Realtek/RTL8168NetworkAdapter.h +++ b/Kernel/Net/Realtek/RTL8168NetworkAdapter.h @@ -42,7 +42,7 @@ private: static constexpr size_t number_of_rx_descriptors = 64; static constexpr size_t number_of_tx_descriptors = 16; - RTL8168NetworkAdapter(StringView, PCI::DeviceIdentifier const&, u8 irq, NonnullOwnPtr registers_io_window); + RTL8168NetworkAdapter(StringView, PCI::DeviceIdentifier const&, InterruptNumber irq, NonnullOwnPtr registers_io_window); virtual bool handle_irq() override; virtual StringView class_name() const override { return "RTL8168NetworkAdapter"sv; } diff --git a/Kernel/Time/HardwareTimer.h b/Kernel/Time/HardwareTimer.h index b3ad914aa20..cc0e831b720 100644 --- a/Kernel/Time/HardwareTimer.h +++ b/Kernel/Time/HardwareTimer.h @@ -91,7 +91,7 @@ public: virtual size_t ticks_per_second() const override { return m_frequency; } protected: - HardwareTimer(u8 irq_number, Function callback = nullptr) + HardwareTimer(InterruptNumber irq_number, Function callback = nullptr) : IRQHandler(irq_number) , m_callback(move(callback)) { @@ -143,7 +143,7 @@ public: virtual size_t ticks_per_second() const override { return m_frequency; } protected: - HardwareTimer(u8 irq_number, Function callback = nullptr) + HardwareTimer(InterruptNumber irq_number, Function callback = nullptr) : GenericInterruptHandler(irq_number) , m_callback(move(callback)) { diff --git a/Userland/Utilities/lsirq.cpp b/Userland/Utilities/lsirq.cpp index e720e85b18c..88952579fbd 100644 --- a/Userland/Utilities/lsirq.cpp +++ b/Userland/Utilities/lsirq.cpp @@ -35,7 +35,7 @@ ErrorOr serenity_main(Main::Arguments) json.as_array().for_each([cpu_count](JsonValue const& value) { auto& handler = value.as_object(); auto purpose = handler.get_byte_string("purpose"sv).value_or({}); - auto interrupt = handler.get_u8("interrupt_line"sv).value(); + auto interrupt = handler.get_integer("interrupt_line"sv).value(); auto controller = handler.get_byte_string("controller"sv).value_or({}); auto call_counts = handler.get_array("per_cpu_call_counts"sv).value();