apic.h

Go to the documentation of this file.

 
#ifndef MAXOS_HARDWARECOMMUNICATION_APIC_H
#define MAXOS_HARDWARECOMMUNICATION_APIC_H
 
#include <libcommon/macros.h>
#include <libcommon/port.h>
 
#include <hardwarecommunication/acpi.h>
#include <memory/physical.h>
 
 
namespace MaxOS::hardwarecommunication {
 
    enum LAPICSendInterruptFlags {
        SEND_ALL        = (1 << 0),
        EXCLUDE_SELF    = (1 << 1),
    };
 
    class LocalAPIC {
 
        private:
            uint64_t m_apic_base = 0;
            uint64_t m_apic_base_high = 0;
            uint32_t m_id = 0;
            bool m_x2apic = false;
 
        public:
            LocalAPIC();
            ~LocalAPIC();
 
            [[nodiscard]] uint32_t read(uint32_t reg) const;
            void write(uint32_t reg, uint32_t value) const;
 
            [[nodiscard]] uint32_t id() const;
            void send_eoi() const;
            void send_icr(uint32_t icr_low, uint32_t icr_high, bool use_shorthand) const;
 
            void send_init(uint8_t apic_id, bool assert) const;
            void send_startup(uint8_t apic_id, uint8_t vector) const;
            void send_interrupt(uint8_t apic_id, uint8_t vector, size_t flags) const;
 
    };
 
    typedef struct PACKED MADT {
        ACPISDTHeader header;               
        uint32_t local_apic_address;        
        uint32_t flags;                     
    } madt_t;
 
    typedef struct PACKED MADTEntry {
        uint8_t type;       
        uint8_t length;     
    } madt_entry_t;
 
    enum class MADT_TYPE {
        PROCESSOR_APIC,
        IO_APIC,
        INTERRUPT_SOURCE_OVERRIDE,
        NMI_SOURCE,
        APIC_NMIS,
        APIC_ADDRESS_OVERRIDE,
        PROCESSOR_X2APIC,
    };
 
    typedef struct PACKED MADT_IO_APIC {
        uint8_t io_apic_id;                         
        uint8_t reserved;                           
        uint32_t io_apic_address;                   
        uint32_t global_system_interrupt_base;      
    } madt_io_apic_t;
 
    typedef struct PACKED MADT_PROCESSOR_APIC {
        uint8_t processor_id;   
        uint8_t apic_id;        
        uint32_t flags;         
    } madt_processor_apic_t;
 
    typedef union RedirectionEntry {
        struct PACKED {
            uint64_t vector : 8;             
            uint64_t delivery_mode : 3;      
            uint64_t destination_mode : 1;   
            uint64_t delivery_status : 1;    
            uint64_t pin_polarity : 1;       
            uint64_t remote_irr : 1;         
            uint64_t trigger_mode : 1;       
            uint64_t mask : 1;               
            uint64_t reserved : 39;          
            uint64_t destination : 8;        
        };          
 
        uint64_t raw;                    
    } redirection_entry_t;
 
    enum DeliveryMode {
        FIXED = 0,
        LOWEST_PRIORITY = 1,
        SMI = 2,
        NMI = 4,
        INIT = 5,
        EXTINT = 7,
    };
 
    typedef struct InterruptRedirect {
 
        uint8_t type;           
        uint8_t index;          
        uint8_t interrupt;      
        uint8_t destination;    
        uint32_t flags;         
        bool mask;              
 
    } interrupt_redirect_t;
 
    typedef struct PACKED Override {
 
        uint8_t bus;                        
        uint8_t source;                     
        uint32_t global_system_interrupt;   
        uint16_t flags;                     
 
    } override_t;
 
    class IOAPIC {
        private:
            AdvancedConfigurationAndPowerInterface* m_acpi;
            MADT* m_madt = { nullptr };
            uint64_t m_address = 0;
            uint64_t m_address_high = 0;
            uint32_t m_version = 0;
            uint8_t m_max_redirect_entry = 0;
 
            uint8_t m_override_array_size = 0;
            Override m_override_array[0x10] = { };
 
            void read_redirect(uint8_t index, RedirectionEntry* entry) const;
            void write_redirect(uint8_t index, RedirectionEntry* entry) const;
 
        public:
            explicit IOAPIC(AdvancedConfigurationAndPowerInterface* acpi);
            ~IOAPIC();
 
            [[nodiscard]] uint32_t read(uint32_t reg) const;
            void write(uint32_t reg, uint32_t value) const;
 
            void set_redirect(interrupt_redirect_t* redirect);
            void set_redirect_mask(uint8_t index, bool mask);
 
            MADTEntry* get_madt_item(MADT_TYPE type, uint8_t index);
 
    };
 
    class AdvancedProgrammableInterruptController {
 
        private:
            LocalAPIC* m_local_apic;
            IOAPIC* m_io_apic;
 
            common::Port8BitSlow m_pic_master_command_port;
            common::Port8BitSlow m_pic_master_data_port;
            common::Port8BitSlow m_pic_slave_command_port;
            common::Port8BitSlow m_pic_slave_data_port;
 
            void disable_pic();
 
        public:
            explicit AdvancedProgrammableInterruptController(AdvancedConfigurationAndPowerInterface* acpi);
            ~AdvancedProgrammableInterruptController();
 
            [[nodiscard]] LocalAPIC* local_apic() const;
            [[nodiscard]] IOAPIC* io_apic() const;
 
    };
 
}
 
 
#endif // MAXOS_HARDWARECOMMUNICATION_APIC_H