MaxOS::hardwarecommunication::IOAPIC Class Reference

Handles the IO APIC in the system (one per system) More...

#include <apic.h>

Public Member Functions
	IOAPIC (AdvancedConfigurationAndPowerInterface *acpi)
	Construct a new IO APIC object. Maps the IO APIC registers and reads the MADT to get information about the IO APICs and interrupt source overrides.
uint32_t	read (uint32_t reg) const
	read a value from a IO Apic register
void	write (uint32_t reg, uint32_t value) const
	write a value to an IO Apic register
void	set_redirect (interrupt_redirect_t *redirect)
	Redirect a system interrupt to a different IRQ.
void	set_redirect_mask (uint8_t index, bool mask)
	Enables/Disables an interrupt redirect by masking it.
MADTEntry *	get_madt_item (MADT_TYPE type, uint8_t index)
	Get an item in the MADT.

Detailed Description

Handles the IO APIC in the system (one per system)

Definition at line 205 of file apic.h.

Constructor & Destructor Documentation

IOAPIC()

IOAPIC::IOAPIC ( AdvancedConfigurationAndPowerInterface *  acpi )

explicit

Construct a new IO APIC object. Maps the IO APIC registers and reads the MADT to get information about the IO APICs and interrupt source overrides.

Parameters

acpi	The ACPI interface to get the MADT from

Definition at line 245 of file apic.cpp.

: m_acpi(acpi)
{
 
    // Get the information about the IO APIC
    m_madt = (MADT*) m_acpi->find("APIC");
    MADTEntry* io_apic_item = get_madt_item(MADT_TYPE::IO_APIC, 0);
 
    // Get the IO APIC
    auto* io_apic = (MADT_IO_APIC*) PhysicalMemoryManager::to_io_region((uint64_t) io_apic_item + sizeof(MADTEntry));
    PhysicalMemoryManager::s_current_manager->map((physical_address_t*) io_apic_item, (virtual_address_t*) (io_apic - sizeof(MADTEntry)), PRESENT | WRITE);
 
    // Map the IO APIC address to the higher half
    m_address = io_apic->io_apic_address;
    m_address_high = (uint64_t) PhysicalMemoryManager::to_io_region(m_address);
    PhysicalMemoryManager::s_current_manager->map((physical_address_t*) m_address, (virtual_address_t*) m_address_high, PRESENT | WRITE);
    Logger::DEBUG() << "IO APIC Address: phy=0x" << m_address << ", virt=0x" << m_address_high << "\n";
 
    // Get the IO APIC version and max redirection entry
    m_version = read(0x1);
    m_max_redirect_entry = (uint8_t) (m_version >> 16);
 
    // Log the IO APIC information
    Logger::DEBUG() << "IO APIC Version: 0x" << (uint64_t) (m_version & 0xFF) << "\n";
    Logger::DEBUG() << "IO APIC Max Redirection Entry: 0x" << (uint64_t) m_max_redirect_entry << "\n";
 
    // Get the source override item
    MADTEntry* source_override_item = get_madt_item(MADT_TYPE::IO_APIC, m_override_array_size);
    uint32_t total_length = sizeof(MADT);
    while (total_length < m_madt->header.length && m_override_array_size < 0x10) { // 0x10 is the max items
 
        total_length += source_override_item->length;
 
        // If there is an override, populate the array
        if (source_override_item != nullptr && source_override_item->type == 2) {
 
            // Get the override and populate the array
            auto* override = (Override*) (source_override_item + 1);
            m_override_array[m_override_array_size].bus = override->bus;
            m_override_array[m_override_array_size].source = override->source;
            m_override_array[m_override_array_size].global_system_interrupt = override->global_system_interrupt;
            m_override_array[m_override_array_size].flags = override->flags;
            m_override_array_size++;
        }
 
        // Get the next item
        source_override_item = get_madt_item(MADT_TYPE::IO_APIC, m_override_array_size);
        if (source_override_item == nullptr)
            break;
    }
 
    Logger::DEBUG() << "IO APIC Source Overrides: 0x" << m_override_array_size << "\n";
}

References MaxOS::hardwarecommunication::Override::bus, MaxOS::Logger::DEBUG(), MaxOS::hardwarecommunication::AdvancedConfigurationAndPowerInterface::find(), MaxOS::hardwarecommunication::Override::flags, get_madt_item(), MaxOS::hardwarecommunication::Override::global_system_interrupt, MaxOS::hardwarecommunication::MADTEntry::length, MaxOS::memory::PhysicalMemoryManager::map(), MaxOS::memory::PRESENT, read(), MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::hardwarecommunication::Override::source, MaxOS::memory::PhysicalMemoryManager::to_io_region(), MaxOS::hardwarecommunication::MADTEntry::type, and MaxOS::memory::WRITE.

Member Function Documentation

get_madt_item()

MADTEntry * IOAPIC::get_madt_item	(	MADT_TYPE	type,
		uint8_t	index
	)

Get an item in the MADT.

Parameters

type	The type of item
index	The index of the item

Returns

The item or null if not found

Definition at line 308 of file apic.cpp.

                                                              {
 
    // The item starts at the start of the MADT
    auto* item = (MADTEntry*) ((uint64_t) m_madt + sizeof(MADT));
    uint64_t total_length = 0;
    uint8_t current_index = 0;
 
    // Loop through the items
    while (total_length + sizeof(MADT) < m_madt->header.length && current_index <= index) {
 
        // Correct type
        if (item->type == (uint8_t)type) {
 
            // Correct index means found
            if (current_index == index)
                return item;
 
            // Right type wrong index so move on
            current_index++;
        }
 
        // Increment the total length
        total_length += item->length;
        item = (MADTEntry*) ((uint64_t) item + item->length);
    }
 
    // No item found
    return nullptr;
}

References MaxOS::hardwarecommunication::MADT::header, MaxOS::hardwarecommunication::ACPISDTHeader::length, and MaxOS::hardwarecommunication::MADTEntry::length.

Referenced by MaxOS::system::CPU::find_cores(), and IOAPIC().

read()

uint32_t IOAPIC::read

(

uint32_t

reg

)

const

read a value from a IO Apic register

Parameters

reg	The register to read from

Returns

The value at the register

Definition at line 344 of file apic.cpp.

                                        {
 
    // Tell the APIC what register to read from
    *(volatile uint32_t*) (m_address_high + 0x00) = reg;
 
    // Read the value
    return *(volatile uint32_t*) (m_address_high + 0x10);
}

Referenced by IOAPIC().

set_redirect()

void IOAPIC::set_redirect

(

interrupt_redirect_t *

redirect

)

Redirect a system interrupt to a different IRQ.

Parameters

redirect

The redirection entry

Definition at line 412 of file apic.cpp.

                                                        {
 
    // Create the redirection entry
    RedirectionEntry entry = {};
    entry.raw = redirect->flags | (redirect->interrupt & 0xFF);
    entry.destination = redirect->destination;
    entry.mask = redirect->mask;
 
    // Check if a global system interrupt is used
    for (uint8_t i = 0; i < m_override_array_size; i++) {
 
        if (m_override_array[i].source != redirect->type)
            continue;
 
        // Set the lower 4 bits of the pin
        entry.pin_polarity = ((m_override_array[i].flags & 0b11) == 2) ? 0b1 : 0b0;
        entry.pin_polarity = (((m_override_array[i].flags >> 2) & 0b11) == 2) ? 0b1 : 0b0;
 
        // Set the trigger mode
        entry.trigger_mode = (((m_override_array[i].flags >> 2) & 0b11) == 2);
        break;
 
    }
 
    // Write the redirect
    write_redirect(redirect->index, &entry);
}

References MaxOS::hardwarecommunication::InterruptRedirect::destination, MaxOS::hardwarecommunication::InterruptRedirect::flags, MaxOS::hardwarecommunication::Override::flags, MaxOS::hardwarecommunication::InterruptRedirect::index, MaxOS::hardwarecommunication::InterruptRedirect::interrupt, MaxOS::hardwarecommunication::InterruptRedirect::mask, MaxOS::hardwarecommunication::RedirectionEntry::raw, and MaxOS::hardwarecommunication::InterruptRedirect::type.

Referenced by MaxOS::hardwarecommunication::InterruptHandler::InterruptHandler().

set_redirect_mask()

void IOAPIC::set_redirect_mask	(	uint8_t	index,
		bool	mask
	)

Enables/Disables an interrupt redirect by masking it.

Parameters

index	The index of the redirect mask
mask	True = masked = disabled, False = unmasked = enabled

Definition at line 446 of file apic.cpp.

                                                       {
 
    // Read the current entry
    RedirectionEntry entry = {};
    read_redirect(index, &entry);
 
    // Set the mask
    entry.mask = mask;
    write_redirect(index, &entry);
}

write()

void IOAPIC::write	(	uint32_t	reg,
		uint32_t	value
	)		const

write a value to an IO Apic register

Parameters

reg	The register to write to
value	The value to set the register to

Definition at line 359 of file apic.cpp.

                                                     {
 
    // Write the register
    *(volatile uint32_t*) (m_address_high + 0x00) = reg;
 
    // Write the value
    *(volatile uint32_t*) (m_address_high + 0x10) = value;
}

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/hardwarecommunication/apic.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/hardwarecommunication/apic.cpp