mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-24 18:24:45 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Kernel/Interrupts/SharedIRQHandler.h

47 lines
1.5 KiB
C
Raw Normal View History

Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
/*
* Copyright (c) 2020, Liav A. <liavalb@hotmail.co.il>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
*/
#pragma once
#include <AK/NonnullOwnPtr.h>
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 22:33:41 +02:00
#include <AK/RefPtr.h>
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
#include <AK/Types.h>
#include <Kernel/Interrupts/GenericInterruptHandler.h>
Kernel: Pull apart CPU.h This does not add any functional changes
2021-06-21 17:34:09 +02:00
#include <Kernel/Interrupts/IRQController.h>
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
namespace Kernel {
class IRQHandler;
class SharedIRQHandler final : public GenericInterruptHandler {
public:
static void initialize(u8 interrupt_number);
virtual ~SharedIRQHandler();
Kernel/Interrupts: Return boolean on whether we handled the interrupt If we are in a shared interrupt handler, the called handlers might indicate it was not their interrupt, so we should not increment the call counter of these handlers.
2021-06-05 09:00:18 +03:00
virtual bool handle_interrupt(const RegisterState& regs) override;
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
void register_handler(GenericInterruptHandler&);
void unregister_handler(GenericInterruptHandler&);
virtual bool eoi() override;
Kernel/Interrupts: Enumerate nested handlers in a shared handler When asked to enumerate all interrupt handlers, display all shared handlers within it instead of just returning the responsible handler of them.
2021-06-05 07:50:27 +03:00
void enumerate_handlers(Function<void(GenericInterruptHandler&)>&);
Kernel: Use IntrusiveList for keeping track of GenericInterruptHandlers
2021-07-21 20:21:29 +02:00
virtual size_t sharing_devices_count() const override { return m_handlers.size_slow(); }
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
virtual bool is_shared_handler() const override { return true; }
virtual bool is_sharing_with_others() const override { return false; }
Kernel: Change HandlerPurpose to HandlerType Also, GenericInterruptHandler class requires to implement two new methods.
2020-03-05 19:13:55 +02:00
virtual HandlerType type() const override { return HandlerType::SharedIRQHandler; }
Kernel: Make various T::class_name() and similar return StringView Instead of returning char const*, we can also give you a StringView.
2021-07-11 01:46:09 +02:00
virtual StringView purpose() const override { return "Shared IRQ Handler"; }
virtual StringView controller() const override { return m_responsible_irq_controller->model(); }
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
private:
void enable_interrupt_vector();
void disable_interrupt_vector();
explicit SharedIRQHandler(u8 interrupt_number);
Kernel: Add missing initializer for SharedIRQHandler::m_enabled Found by KUBSAN :^)
2021-02-05 19:43:01 +01:00
bool m_enabled { true };
Kernel: Use IntrusiveList for keeping track of GenericInterruptHandlers
2021-07-21 20:21:29 +02:00
GenericInterruptHandler::List m_handlers;
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 22:33:41 +02:00
RefPtr<IRQController> m_responsible_irq_controller;
Kernel: Add SharedIRQHandler class This class represents a shared interrupt handler. This class will not be created automatically but only if two IRQ Handlers are sharing the same IRQ number.
2020-02-22 19:56:55 +02:00
};
}
Reference in a new issue Copy permalink