SplitIrqHandler.h

/*
 * Copyright (c) 2026, Pedigree Developers
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted.
 */
 
#ifndef PEDIGREE_KERNEL_MACHINE_SPLITIRQHANDLER_H
#define PEDIGREE_KERNEL_MACHINE_SPLITIRQHANDLER_H
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/IrqHandler.h"
#include "pedigree/kernel/machine/ThreadedIrqDispatcher.h"
#include "pedigree/kernel/machine/types.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
 
#include <config.h>
 
class Device;
class IrqManager;
class IrqPolicy;
class String;
 
class EXPORTED_PUBLIC SplitIrqHandler : private HardIrqHandler {
 public:
  enum class HardStageDisposition : size_t {
    NotHandled,
    Handled,
    Deferred,
  };
 
 protected:
  explicit SplitIrqHandler(const String& name);
  virtual ~SplitIrqHandler();
 
  bool initialiseSplitIrq();
 
  irq_id_t registerIsaSplitIrq(IrqManager& manager, uint8_t irq, const IrqPolicy& policy);
  irq_id_t registerPciSplitIrq(IrqManager& manager, Device& device, const IrqPolicy& policy);
 
  bool shutdownSplitIrq();
 
  virtual HardStageDisposition hardIrq(irq_id_t number, InterruptState& state, size_t& work) = 0;
 
  virtual void threadedIrq(size_t work) = 0;
 
  virtual bool quiesceIrqSources() = 0;
 
  virtual void rearmIrqSources(size_t work) = 0;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using RegistrationPublishedHook = void (*)(SplitIrqHandler*);
 
  HardIrqHandler* hardHandlerForTest();
  void setRegistrationPublishedHookForTest(RegistrationPublishedHook hook);
  size_t publicationFailuresForTest() const;
  size_t pendingWorkForTest() const;
  size_t deferredIrqsForTest() const;
  size_t completedBatchesForTest() const;
  bool publishWorkForTest(size_t work);
  void rejectNextPublicationForTest();
#endif
 
 private:
  static constexpr size_t MaxRegistrations = 16;
 
  struct Registration {
    IrqManager* manager = nullptr;
    irq_id_t id = 0;
  };
 
  ::HardIrqDisposition irq(irq_id_t number, InterruptState& state) final;
  static void dispatchThreaded(void* context, uint8_t line, size_t cookie);
  void dispatchThreaded();
 
  bool publishWork(size_t work);
 
  Registration m_Registrations[MaxRegistrations];
  size_t m_RegistrationCount;
  Atomic<size_t> m_LifecycleBusy;
  Atomic<size_t> m_AcceptingRegistrations;
  ThreadedIrqDispatcher m_Dispatcher;
  Spinlock m_StateLock;
  bool m_Quiescing;
  Atomic<size_t> m_Stopping;
  Atomic<size_t> m_PublicationFailures;
  Atomic<size_t> m_DeferredIrqs;
  Atomic<size_t> m_CompletedBatches;
  size_t m_PendingWork;
  bool m_Started;
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  RegistrationPublishedHook m_RegistrationPublishedHook;
#endif
 
  SplitIrqHandler(const SplitIrqHandler&) = delete;
  SplitIrqHandler& operator=(const SplitIrqHandler&) = delete;
};
 
#endif