Pc.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 "Pc.h"
#if ACPI
#include "Acpi.h"
#endif
#if MULTIPROCESSOR
#include "Apic.h"
#endif
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Bus.h"
#include "pedigree/kernel/machine/Controller.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/machine/Pci.h"
#include "pedigree/kernel/panic.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/new"
 
#include "Pic.h"
#include "Pit.h"
#include "Rtc.h"
 
class IrqManager;
class Keyboard;
class SchedulerTimer;
class Serial;
class Timer;
class Vga;
 
Pc Pc::m_Instance;
 
#if X64
namespace {
constexpr uint32_t Ia32TscAux = 0xC0000103;
constexpr uint32_t RdtscpFeature = 1u << 27;
 
bool supportsRdtscp() {
  uint32_t maxLeaf, unusedEax, unusedEbx, unusedEcx, unusedEdx;
  Processor::cpuid(0x80000000, 0, maxLeaf, unusedEbx, unusedEcx, unusedEdx);
  if (maxLeaf < 0x80000001) {
    return false;
  }
 
  Processor::cpuid(0x80000001, 0, unusedEax, unusedEbx, unusedEcx, unusedEdx);
  return (unusedEdx & RdtscpFeature) != 0;
}
 
void initialiseVdsoCpuId() {
  if (!supportsRdtscp()) {
    return;
  }
 
  const size_t processor = Processor::index();
  if (processor >= Processor::getCount()) {
    return;
  }
  Processor::writeMachineSpecificRegister(Ia32TscAux, static_cast<uint32_t>(processor));
}
}  // namespace
#endif
 
#if MULTIPROCESSOR
namespace {
bool reportProcessorControlResult(LocalApic::ProcessorControlResult result, const char* operation) {
  if (result != LocalApic::ProcessorControlResult::Success &&
      Processor::tlbInvalidationTerminal()) {
    // The terminal TLB coordinator may hold an outer allocator lock. Its
    // retry loop must not format or publish diagnostics before peers stop.
    return false;
  }
 
  switch (result) {
    case LocalApic::ProcessorControlResult::Success:
      return true;
    case LocalApic::ProcessorControlResult::InvalidState:
      ERROR_NOLOCK("Pc: " << operation << " failed: invalid processor state");
      break;
    case LocalApic::ProcessorControlResult::SubmissionFailed:
      ERROR_NOLOCK("Pc: " << operation << " IPI transaction failed");
      break;
    case LocalApic::ProcessorControlResult::AcknowledgementTimedOut:
      ERROR_NOLOCK("Pc: " << operation << " acknowledgement timed out");
      break;
    case LocalApic::ProcessorControlResult::DrainTimedOut:
      ERROR_NOLOCK("Pc: " << operation << " processor-control drain timed out");
      break;
  }
  return false;
}
}  // namespace
#endif
 
bool Pc::supportsPowerOff() const {
#if ACPI
  return Acpi::instance().supportsPowerOff();
#else
  return false;
#endif
}
 
bool Pc::prepareShutdown(ShutdownType type) {
#if ACPI
  return Acpi::instance().prepareShutdown(type == ShutdownType::PowerOff);
#else
  return true;
#endif
}
 
const char* Pc::finalShutdown(ShutdownType type) {
  if (type == ShutdownType::PowerOff) {
    NOTICE_NOLOCK("Powering off...");
#if ACPI
    return Acpi::instance().powerOff();
#else
    return "ACPI power-off support is disabled.";
#endif
  } else if (type == ShutdownType::Restart) {
    NOTICE_NOLOCK("Rebooting...");
#if ACPI
    Acpi::instance().reset();
#endif
    // The controller is already quiesced, so terminal reset can access it
    // without acquiring the keyboard driver's retired locks.
    for (size_t i = 0; i < 100000; ++i) {
      uint8_t status;
      asm volatile("inb %1, %0" : "=a"(status) : "Nd"(uint16_t(0x64)));
      if (!(status & 2)) {
        asm volatile("outb %0, %1" : : "a"(uint8_t(0xfe)), "Nd"(uint16_t(0x64)));
        break;
      }
    }
    for (size_t i = 0; i < 100000; ++i)
      asm volatile("pause");
    Processor::reset();
    return "The firmware reset request returned without restarting the computer.";
  } else {
    NOTICE_NOLOCK("System halted");
  }
 
  return nullptr;
}
 
void Pc::initialise() {
  // Initialise Vga
  if (m_Vga->initialise() == false)
    panic("Pc: Vga initialisation failed");
 
  uint8_t rtcCenturyIndex = 0;
#if ACPI
  Acpi& acpi = Acpi::instance();
  acpi.initialise();
  rtcCenturyIndex = acpi.getRtcCenturyIndex();
#endif
 
  Rtc& rtc = Rtc::instance();
  if (rtc.initialise1(rtcCenturyIndex) == false)
    panic("Pc: Rtc initialisation phase 1 failed");
  if (rtc.initialise2() == false)
    panic("Pc: Rtc initialisation phase 2 failed");
 
  bool localApicInitialised = false;
#if MULTIPROCESSOR && ACPI
  const uint64_t localApicAddress = acpi.getLocalApicAddress();
  if (acpi.validApicInfo() && localApicAddress && m_LocalApic->initialise(localApicAddress)) {
    localApicInitialised = true;
    NOTICE("Local APIC initialised");
  }
#endif
 
  m_SchedulerTimerSelection.recordLocalApicInitialisation(localApicInitialised);
 
  NOTICE("Falling back to dual 8259 PIC Mode");
  Pic& pic = Pic::instance();
  if (pic.initialise() == false) {
    panic("Pc: Pic initialisation failed");
  }
 
  // Initialise serial ports.
  m_pSerial[0]->setBase(0x3F8);
  m_pSerial[1]->setBase(0x2F8);
  m_pSerial[2]->setBase(0x3E8);
  m_pSerial[3]->setBase(0x2E8);
 
  if (m_SchedulerTimerSelection.usesPit()) {
    NOTICE("Using PIT scheduler timer fallback");
    Pit& pit = Pit::instance();
    if (pit.initialise() == false)
      panic("Pc: Pit initialisation failed");
  }
 
  // Set up PS/2
  m_Ps2Controller->initialise();
  m_Keyboard->initialise();
 
#if X64
  initialiseVdsoCpuId();
#endif
  m_bInitialised = true;
}
 
void Pc::deinitialise() {
  if (!m_bInitialised) {
    return;
  }
 
  setShutdownPhase(ShutdownPhase::Devices, "RTC: stopping callbacks");
  Rtc::instance().uninitialise();
  setShutdownPhase(ShutdownPhase::Devices, "PS/2: stopping controller");
  m_Ps2Controller->uninitialise();
  setShutdownPhase(ShutdownPhase::Devices, "PS/2: joining keyboard reader");
  m_Keyboard->stopReaderThread();
  if (m_SchedulerTimerSelection.usesPit()) {
    setShutdownPhase(ShutdownPhase::Devices, "PIT: stopping callbacks");
    Pit::instance().uninitialise();
  }
  setShutdownPhase(ShutdownPhase::Devices, "IRQ: joining interrupt workers");
  if (!Pic::instance().shutdownThreaded()) {
    panic("Shutdown aborted: threaded IRQ workers did not stop");
  }
  m_bInitialised = false;
}
 
#if MULTIPROCESSOR
void Pc::initialiseProcessor() {
  // TODO: we might need to initialise per-processor ACPI shit, no idea atm
 
  // Initialise the local APIC
  if (m_LocalApic->initialiseProcessor() == false)
    panic("Pc::initialiseProcessor(): Failed to initialise the local APIC");
 
  // AP startup calls this before creating its scheduler and enabling
  // interrupts, so no migratable work can observe an unanchored local TSC.
  Rtc::instance().initialiseProcessorClock();
  initialiseVdsoCpuId();
}
#endif
 
void Pc::initialise3() {
  if (!Pic::instance().initialiseThreaded()) {
    panic("Pc: threaded IRQ worker initialisation failed");
  }
  if (!Rtc::instance().initialise3()) {
    panic("Pc: RTC bottom-half initialisation failed");
  }
  if (!m_Ps2Controller->initialise3()) {
    panic("Pc: PS/2 bottom-half initialisation failed");
  }
  m_Keyboard->startReaderThread();
}
 
void Pc::initialiseDeviceTree() {
  for (size_t i = 0; i < 4; ++i) {
    m_pSerial[i] = new X86Serial();
  }
 
  m_Vga = new X86Vga();
 
  m_IsaBus = new Bus("ISA");
  m_AtaMaster = new Controller();
  m_AtaSlave = new Controller();
  m_Watchdog = new Device();
 
  m_Ps2Controller = new Ps2Controller();
  m_pKeyboard = m_Keyboard = new X86Keyboard(m_Ps2Controller);
 
#if MULTIPROCESSOR
  m_LocalApic = new LocalApic();
#endif
 
  // Firstly add the ISA bus.
  m_IsaBus->setSpecificType(String("isa"));
 
  // ATA controllers.
  m_AtaMaster->setSpecificType(String("ata"));
  m_AtaMaster->addresses().pushBack(new Device::Address(String("command"), 0x1F0, 8, true));
  m_AtaMaster->addresses().pushBack(new Device::Address(String("control"), 0x3F0, 8, true));
  m_AtaMaster->setInterruptNumber(14);
  m_IsaBus->addChild(m_AtaMaster);
  m_AtaMaster->setParent(m_IsaBus);
 
  m_AtaSlave->setSpecificType(String("ata"));
  m_AtaSlave->addresses().pushBack(new Device::Address(String("command"), 0x170, 8, true));
  m_AtaSlave->addresses().pushBack(new Device::Address(String("control"), 0x370, 8, true));
  m_AtaSlave->setInterruptNumber(15);
  m_IsaBus->addChild(m_AtaSlave);
  m_AtaSlave->setParent(m_IsaBus);
 
  // PS/2
  m_Ps2Controller->setSpecificType(String("ps2"));
  m_Ps2Controller->addresses().pushBack(new Device::Address(String("ps2-base"), 0x60, 5, true));
  m_Ps2Controller->setInterruptNumber(1);  // 12 for mouse, handled by the driver
  m_IsaBus->addChild(m_Ps2Controller);
  m_Ps2Controller->setParent(m_IsaBus);
 
  // IB700 Watchdog Timer
  m_Watchdog->addresses().pushBack(new Device::Address(String("ib700-base"), 0x441, 4, true));
  m_IsaBus->addChild(m_Watchdog);
  m_Watchdog->setParent(m_IsaBus);
 
  Device::addToRoot(m_IsaBus);
 
  // Initialise the PCI interface
  PciBus::instance().initialise();
}
 
Serial* Pc::getSerial(size_t n) {
  return m_pSerial[n];
}
 
size_t Pc::getNumSerial() {
  return 4;
}
 
Vga* Pc::getVga(size_t n) {
  return m_Vga;
}
 
size_t Pc::getNumVga() {
  return 1;
}
 
IrqManager* Pc::getIrqManager() {
  return &Pic::instance();
}
 
SchedulerTimer* Pc::getSchedulerTimer() {
#if MULTIPROCESSOR
  if (m_SchedulerTimerSelection.usesLocalApic()) {
    return m_LocalApic;
  }
#endif
  return &Pit::instance();
}
 
Timer* Pc::getTimer() {
  return &Rtc::instance();
}
 
Keyboard* Pc::getKeyboard() {
  return m_pKeyboard;
}
 
void Pc::setKeyboard(Keyboard* kb) {
  if (m_pKeyboard) {
    delete m_pKeyboard;
  }
 
  m_pKeyboard = kb;
}
 
#if MULTIPROCESSOR
bool Pc::quiesceAllOtherProcessors() {
  const size_t processorCount = Processor::getCount();
  return reportProcessorControlResult(
      m_LocalApic->quiesceAllOtherProcessors(processorCount > 1 ? processorCount - 1 : 0),
      "processor quiesce");
}
 
bool Pc::resumeAllOtherProcessors() {
  if (Processor::getCount() <= 1)
    return true;
  return reportProcessorControlResult(m_LocalApic->resumeAllOtherProcessors(), "processor resume");
}
 
bool Pc::stopAllOtherProcessors() {
  const size_t processorCount = Processor::getCount();
  return reportProcessorControlResult(
      m_LocalApic->haltAllOtherProcessors(processorCount > 1 ? processorCount - 1 : 0),
      "processor halt");
}
#endif
 
Pc::Pc()
    : m_pSerial(),
      m_Vga(nullptr),
      m_pKeyboard(nullptr),
#if MULTIPROCESSOR
      m_LocalApic(nullptr),
#endif
      m_SchedulerTimerSelection(),
      m_Keyboard(nullptr),
      m_IsaBus(nullptr),
      m_AtaMaster(nullptr),
      m_AtaSlave(nullptr),
      m_Ps2Controller(nullptr),
      m_Watchdog(nullptr) {
  for (size_t i = 0; i < 4; ++i) {
    m_pSerial[i] = nullptr;
  }
}
 
Pc::~Pc() {}