ladybird/Kernel/Interrupts/GenericInterruptHandler.h

/*
 * Copyright (c) 2020, Liav A. <liavalb@hotmail.co.il>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/HashTable.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <Kernel/Arch/x86/RegisterState.h>

namespace Kernel {

enum class HandlerType : u8 {
    IRQHandler = 1,
    SharedIRQHandler = 2,
    UnhandledInterruptHandler = 3,
    SpuriousInterruptHandler = 4
};

class GenericInterruptHandler {
public:
    static GenericInterruptHandler& from(u8 interrupt_number);
    virtual ~GenericInterruptHandler()
    {
        VERIFY(!m_registered);
    }
    // Note: this method returns boolean value, to indicate if the handler handled
    // the interrupt or not. This is useful for shared handlers mostly.
    virtual bool handle_interrupt(const RegisterState& regs) = 0;

    void will_be_destroyed();
    bool is_registered() const { return m_registered; }
    void register_interrupt_handler();
    void unregister_interrupt_handler();

    u8 interrupt_number() const { return m_interrupt_number; }

    size_t get_invoking_count() const { return m_invoking_count; }

    virtual size_t sharing_devices_count() const = 0;
    virtual bool is_shared_handler() const = 0;
    virtual bool is_sharing_with_others() const = 0;

    virtual HandlerType type() const = 0;
    virtual StringView purpose() const = 0;
    virtual StringView controller() const = 0;

    virtual bool eoi() = 0;
    ALWAYS_INLINE void increment_invoking_counter()
    {
        m_invoking_count++;
    }

protected:
    void change_interrupt_number(u8 number);
    GenericInterruptHandler(u8 interrupt_number, bool disable_remap = false);

    void disable_remap() { m_disable_remap = true; }

private:
    Atomic<u32, AK::MemoryOrder::memory_order_relaxed> m_invoking_count { 0 };
    u8 m_interrupt_number { 0 };
    bool m_disable_remap { false };
    bool m_registered { false };
};
}