modules/drivers/x86/ib700_wdt/main.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 "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/machine/Machine.h"
#include "pedigree/kernel/machine/Timer.h"
#include "pedigree/kernel/machine/TimerHandler.h"
#include "pedigree/kernel/processor/IoBase.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "modules/Module.h"
 
enum Ib700TimeEntries {
  Seconds30 = 0,
  Seconds28 = 1,
  Seconds26 = 2,
  Seconds24 = 3,
  Seconds22 = 4,
  Seconds20 = 5,
  Seconds18 = 6,
  Seconds16 = 7,
  Seconds14 = 8,
  Seconds12 = 9,
  Seconds10 = 10,
  Seconds8 = 11,
  Seconds6 = 12,
  Seconds4 = 13,
  Seconds2 = 14,
  Seconds0 = 15,
};
 
class Ib700Watchdog : public Device, public TimerHandler {
 public:
  Ib700Watchdog(Device* pDev);
 
  virtual ~Ib700Watchdog();
 
  virtual bool initialise();
 
  void shutdown();
 
  virtual void getName(String& str);
 
  virtual void timer(uint64_t delta);
 
 private:
  IoBase* m_pBase;
  Timer* m_pTimer;
  uint64_t m_RefreshRemaining;
};
 
static Vector<Ib700Watchdog*> g_Watchdogs;
 
static bool entry() {
  auto f = [](Device* p) {
    if (p->addresses().count() > 0) {
      if (p->addresses()[0]->m_Name.compare("ib700-base")) {
        Ib700Watchdog* pNewChild = new Ib700Watchdog(p);
        if (pNewChild->initialise()) {
          g_Watchdogs.pushBack(pNewChild);
          return static_cast<Device*>(pNewChild);
        } else {
          ERROR("IB700 initialisation failed!");
          delete pNewChild;
        }
      }
    }
 
    return p;
  };
 
  auto c = pedigree_std::make_callable(f);
  Device::foreach (c, 0);
 
  return true;
}
 
static void exit() {
  auto f = [](Device* device) {
    for (auto watchdog : g_Watchdogs) {
      if (device == watchdog) {
        // Restore a generic device node so a later reload can bind it again.
        // Drain the timer callback before Device's transfer constructor takes
        // away the watchdog's I/O mapping.
        watchdog->shutdown();
        return new Device(device);
      }
    }
    return device;
  };
 
  auto c = pedigree_std::make_callable(f);
  Device::foreach (c, 0);
  g_Watchdogs.clear();
}
 
MODULE_INFO("ib700_wdt", &entry, &exit);
 
Ib700Watchdog::Ib700Watchdog(Device* pDev)
    : Device(pDev),
      m_pBase(nullptr),
      m_pTimer(nullptr),
      m_RefreshRemaining(Time::Multiplier::Second) {
  setSpecificType(String("watchdog-timer"));
}
 
Ib700Watchdog::~Ib700Watchdog() {
  shutdown();
}
 
void Ib700Watchdog::shutdown() {
  if (m_pTimer) {
    if (!m_pTimer->unregisterHandler(this)) {
      FATAL("IB700 watchdog could not drain its timer callback");
    }
    m_pTimer = nullptr;
  }
 
  if (m_pBase) {
    // Offset 2 arms the watchdog; only offset 0 disables it.
    m_pBase->write8(0, 0);
    m_pBase = nullptr;
  }
}
 
bool Ib700Watchdog::initialise() {
  m_pBase = addresses()[0]->m_Io;
  if (!m_pBase)
    return false;
 
  // Disable any existing timer.
  m_pBase->write8(0, 0);
 
  // Register ourselves with the core timer so we can continually
  // reset the watchdog timer as needed.
  Timer* t = Machine::instance().getTimer();
  if (t && t->registerHandler(this)) {
    m_pTimer = t;
 
    // A word write also touches the next byte port and rearms QEMU's IB700
    // with the high byte, replacing the intended 10-second timeout.
    m_pBase->write8(Seconds10, 2);
    if (t->supportsDeadlines() &&
        !t->armHandler(this, Time::getTicks() + Time::Multiplier::Second)) {
      shutdown();
      return false;
    }
 
    return true;
  }
 
  return false;
}
 
void Ib700Watchdog::getName(String& str) {
  str.assign("ib700_wdt", 10);
}
 
void Ib700Watchdog::timer(uint64_t delta) {
  if (delta < m_RefreshRemaining) {
    m_RefreshRemaining -= delta;
    if (m_pTimer && m_pTimer->supportsDeadlines() &&
        !m_pTimer->armHandler(this, Time::getTicks() + m_RefreshRemaining)) {
      FATAL("IB700 watchdog could not rearm its timer callback");
    }
    return;
  }
  // RTC callbacks are serialized by their IRQ worker. A delayed callback
  // needs one refresh now, followed by a full interval until the next write.
  m_RefreshRemaining = Time::Multiplier::Second;
  m_pBase->write8(Seconds10, 2);
  if (m_pTimer && m_pTimer->supportsDeadlines() &&
      !m_pTimer->armHandler(this, Time::getTicks() + m_RefreshRemaining)) {
    FATAL("IB700 watchdog could not rearm its timer callback");
  }
}