clock.h

Go to the documentation of this file.

 
#ifndef MAXOS_HARDWARECOMMUNICATION_CLOCK_H
#define MAXOS_HARDWARECOMMUNICATION_CLOCK_H
 
#include <cstdint>
 
#include <libcommon/time.h>
#include <libcommon/vector.h>
#include <libcommon/event.h>
 
#include <hardwarecommunication/interrupts.h>
#include <hardwarecommunication/apic.h>
 
 
namespace MaxOS::hardwarecommunication {
 
    enum class Channel {
        INTERRUPT,
        DRAM_REFRESH,
        SPEAKER,
    };
 
    enum class AccessMode {
        LATCH_COUNT,
        LOW_BYTE,
        HIGH_BYTE,
        LOW_HIGH_BYTE,
    };
 
    enum class OperatingMode {
        INTERRUPT_ON_TERMINAL_COUNT,
        ONE_SHOT,
        RATE_GENERATOR,
        SQUARE_WAVE,
        SOFTWARE_STROBE,
        HARDWARE_STROBE,
    };
 
    enum class BCDMode {
        BINARY,
        BCD,
    };
 
    typedef struct PITCommand {
 
        uint8_t bcd_mode : 1;      
        uint8_t operating_mode : 3;      
        uint8_t access_mode : 2;      
        uint8_t channel : 2;      
 
    } pit_command_t;
 
 
    // Forward declaration
    class Clock;
 
    constexpr uint16_t TICK_CALIBRATE_LENGTH = 10;
 
    class PIT : public InterruptHandler {
            friend Clock;
 
        private:
            uint64_t m_ticks { 0 };
 
            // Ports
            common::Port8Bit m_data_port;
            common::Port8Bit m_command_port;
 
            // APIC
            LocalAPIC* m_local_apic;
            IOAPIC* m_io_apic;
 
            // Funcs
            void handle_interrupt() final;
            uint32_t ticks_per_ms();
 
        public:
            explicit PIT(AdvancedProgrammableInterruptController* apic);
            ~PIT();
 
    };
 
    class Clock : public InterruptHandler {
        private:
 
            uint64_t m_ticks { 0 };
 
            bool m_binary = true;
            bool m_24_hour_clock = true;
 
            // Ports
            common::Port8Bit m_data_port { 0x71 };
            common::Port8Bit m_command_port { 0x70 };
 
            // APIC
            AdvancedProgrammableInterruptController* m_apic;
 
            // Time between events
            uint16_t m_ticks_between_events = 0;
            uint16_t m_ticks_until_next_event = 1;
            uint64_t m_pit_ticks_per_ms = 0;
 
            // Other functions
            void handle_interrupt() final;
            uint8_t read_hardware_clock(uint8_t address);
            [[nodiscard]] uint8_t binary_representation(uint8_t number) const;
 
            inline static Clock* s_active_clock = nullptr;
 
        public:
            explicit Clock(AdvancedProgrammableInterruptController* apic, uint16_t time_between_events = 10);
            ~Clock();
 
            uint64_t clock_accuracy = 1;
 
            void delay(uint32_t milliseconds) const;
 
            void calibrate(uint64_t ms_per_tick = 1);
            void setup_apic_clock(LocalAPIC* local_apic) const;
 
            static Clock* active_clock();
            common::time_t get_time();
    };
 
}
 
 
#endif //MAXOS_HARDWARECOMMUNICATION_CLOCK_H