Rtc.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef KERNEL_MACHINE_X86_COMMON_RTC_H
#define KERNEL_MACHINE_X86_COMMON_RTC_H
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/IrqHandler.h"
#include "pedigree/kernel/machine/Timer.h"
#include "pedigree/kernel/machine/TimerHandlerRegistry.h"
#include "pedigree/kernel/machine/types.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OwnedThread.h"
#include "pedigree/kernel/process/SchedulerWorkerWake.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/IoPort.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/new"
 
#include <config.h>
 
#include "RtcAlarmQueue.h"
#include "TscClock.h"
 
class TimerHandler;
class PerProcessorScheduler;
 
class Rtc : public Timer, private IrqHandler {
 public:
  inline static Rtc& instance() {
    return m_Instance;
  }
 
  //
  // Timer interface
  //
  virtual bool registerHandler(TimerHandler* handler);
  virtual bool unregisterHandler(TimerHandler* handler);
  bool armHandler(TimerHandler* handler, uint64_t absoluteDeadlineNs) override;
  bool supportsDeadlines() const override {
    return m_DeadlineMode.value() != 0;
  }
  void deadlineInterrupt() override;
  virtual void addAlarm(class Event* pEvent, size_t alarmSecs, size_t alarmUsecs = 0);
  virtual void removeAlarm(class Event* pEvent);
  virtual size_t removeAlarm(class Event* pEvent, bool bRetZero);
  virtual size_t getYear();
  virtual uint8_t getMonth();
  virtual uint8_t getDayOfMonth();
  virtual uint8_t getDayOfWeek();
  virtual uint8_t getHour();
  virtual uint8_t getMinute();
  virtual uint8_t getSecond();
  virtual uint64_t getNanosecond();
  Time::Timestamp getUnixTimestamp() override;
  virtual uint64_t getTickCount();
  virtual uint64_t getTickCountNano();
  virtual uint64_t getTickCountNanoFast();
  Time::CpuTimeSample sampleCpuTime() override;
 
  bool initialise1(uint8_t centuryIndex) INITIALISATION_ONLY;
  bool initialise2() INITIALISATION_ONLY;
 
  void initialiseProcessorClock() INITIALISATION_ONLY;
  bool initialise3();
  virtual void synchronise(bool tohw = false);
  void uninitialise();
 
  static EXPORTED_PUBLIC uint8_t readCmos(uint8_t index);
  static EXPORTED_PUBLIC void writeCmos(uint8_t index, uint8_t value);
 
 protected:
  Rtc() INITIALISATION_ONLY;
  inline virtual ~Rtc() {}
 
 private:
  Rtc(const Rtc&);
  Rtc& operator=(const Rtc&);
 
  IrqDisposition irq(irq_id_t number) override;
 
  void processElapsedTime(uint64_t observed);
  uint64_t advanceCivilClock(uint64_t observed, uint64_t* elapsedSeconds = nullptr);
  static int deadlineWorkerEntry(void* context);
  int runDeadlineWorker();
  void publishNextDeadlineLocked();
 
  void setPeriodicInterruptEnabled(bool enabled);
 
  void setIndexLocked(uint8_t index);
  bool waitForUpdateCompletion(uint8_t index);
  bool read(uint8_t index, uint8_t& value);
  uint8_t readLocked(uint8_t index);
  void writeLocked(uint8_t index, uint8_t value);
  uint8_t read(uint8_t index);
  bool write(uint8_t index, uint8_t value);
 
  bool readHardwareClock();
  bool writeHardwareClock();
  bool inhibitClockUpdatesLocked(uint8_t& status);
 
  void drainRemoteAlarmDispatch(class Event* pEvent, void* owner);
 
  class CmosTransactionGuard {
   public:
    explicit CmosTransactionGuard(Mutex& lock);
    ~CmosTransactionGuard();
 
   private:
    static bool waitableContext();
 
    bool m_Waitable;
    TerminationDeferral m_TerminationDeferral;
    Mutex& m_Lock;
    bool m_Owned;
 
    CmosTransactionGuard(const CmosTransactionGuard&) = delete;
    CmosTransactionGuard& operator=(const CmosTransactionGuard&) = delete;
  };
 
  IoPort m_IoPort;
 
  irq_id_t m_IrqId;
 
  size_t m_PeriodicIrqInfoIndex;
 
  uint8_t m_CenturyIndex;
 
  size_t m_Year;
  uint8_t m_Month;
  uint8_t m_DayOfMonth;
  uint8_t m_Hour;
  uint8_t m_Minute;
  uint8_t m_Second;
  uint64_t m_Nanosecond;
 
  Atomic<uint64_t> m_TickCount;
 
  uint64_t m_ProcessedTickCount;
 
  struct periodicIrqInfo_t {
    size_t Hz;
    uint8_t rateBits;
    uint64_t ns[2];
  };
 
  static periodicIrqInfo_t periodicIrqInfo[12];
 
  static Rtc m_Instance;
 
  TimerHandlerRegistry m_HandlerRegistry;
 
  PerProcessorScheduler* m_DeadlineScheduler;
  OwnedThread m_DeadlineWorker;
  WaitQueue m_DeadlineWaiters;
  SchedulerWorkerWake m_DeadlineWake;
  Atomic<size_t> m_DeadlinePending;
  Atomic<size_t> m_StopDeadlineWorker;
  Atomic<size_t> m_DeadlineMode;
 
  using Alarm = RtcAlarmQueue::Record;
 
  RtcAlarmQueue m_AlarmQueue;
  Spinlock m_Lock;
 
  Mutex m_CmosLock;
 
  PcTscClock::Calibration m_TscCalibration;
 
  uint64_t m_Tsc0;
 
  PcTscClock::MonotonicPublication m_MonotonicTicks;
};
 
#endif