Pit.cc

/*
 * 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.
 */
 
#include "Pit.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/IrqManager.h"
#include "pedigree/kernel/machine/Machine.h"
#include "pedigree/kernel/machine/SchedulerTimerDispatchCleanup.h"
#include "pedigree/kernel/machine/SchedulerTimerHandler.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/types.h"
 
#ifdef BOCHS
#define PIT_FREQUENCY 10
#else
#define PIT_FREQUENCY 100
#endif
 
Pit Pit::m_Instance;
 
uint64_t Pit::nominalQuantumNs() const {
  return uint64_t(1000000000) / PIT_FREQUENCY;
}
 
bool Pit::registerHandler(SchedulerTimerHandler* handler) {
  return m_Handler.publish(0, handler);
}
 
bool Pit::removeHandler(SchedulerTimerHandler* handler) {
  return canRemoveHandlerInCurrentContext() && m_Handler.unpublish(0, handler);
}
 
bool Pit::initialise() {
  // Allocate the PIT I/O range
  if (m_IoPort.allocate(0x40, 4) == false)
    return false;
 
  // Allocate the IRQ
  IrqManager& irqManager = *Machine::instance().getIrqManager();
  m_IrqId = irqManager.registerSchedulerIrqHandler(0, this, IrqPolicy::edgeHard());
  if (m_IrqId == 0)
    return false;
 
  // Set the PIT frequency
  // The value we send to the PIT is the value to divide it's input clock
  // (1193180 Hz) by, to get our required frequency. Important to note is
  // that the divisor must be small enough to fit into 16-bits.
  size_t divisor = 1193180 / PIT_FREQUENCY;
 
  // Send the command byte.
  m_IoPort.write8(0x36, 3);
 
  // Divisor has to be sent byte-wise, so split here into upper/lower bytes.
  uint8_t l = divisor & 0xFF;
  uint8_t h = (divisor >> 8) & 0xFF;
 
  // Send the frequency divisor.
  m_IoPort.write8(l, 0);
  m_IoPort.write8(h, 0);
 
  return true;
}
void Pit::uninitialise() {
  // TODO: Reset the PIT frequency
 
  // Free the IRQ
  if (m_IrqId != 0) {
    IrqManager& irqManager = *Machine::instance().getIrqManager();
    if (!irqManager.unregisterSchedulerIrqHandler(m_IrqId, this)) {
      FATAL("PIT teardown could not remove its direct IRQ route");
    }
    m_IrqId = 0;
  }
 
  // Free the PIT I/O range
  m_IoPort.free();
 
  // Source teardown does not confer ownership of the scheduler callback.
  // Its exact owner remains responsible for unpublishing it.
}
 
Pit::Pit() : m_IoPort("PIT"), m_IrqId(0), m_Handler() {}
 
void Pit::schedulerIrq(irq_id_t number, InterruptState& state) {
  SchedulerTimerHandlerSlot::DispatchGuard dispatch;
  if (LIKELY(m_Handler.beginDispatch(0, dispatch))) {
    SchedulerTimerDispatchCleanup dispatchCleanup(dispatch);
    ExecutionContextGuard schedulerContext(ExecutionContext::SchedulerIrq);
    dispatch.handler()->timer(nominalQuantumNs(), state);
  }
 
  // Processor::information().getScheduler().checkEventState(state.getStackPointer());
}