387 lines
14 KiB
C#
387 lines
14 KiB
C#
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: RTClock.cs
|
|
//
|
|
// Useful reference URLs:
|
|
// http://developer.intel.com/design/archives/periphrl/index.htm
|
|
// http://developer.intel.com/design/archives/periphrl/docs/7203.htm
|
|
// http://developer.intel.com/design/archives/periphrl/docs/23124406.htm
|
|
// http://www.cebix.net/downloads/bebox/bq3285.pdf
|
|
//
|
|
|
|
//#define SAMPLE_PC
|
|
|
|
using Microsoft.Singularity.Io;
|
|
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Threading;
|
|
|
|
using Microsoft.Singularity.Configuration;
|
|
|
|
namespace Microsoft.Singularity.Hal
|
|
{
|
|
[DriverCategory]
|
|
[Signature("/pnp/PNP0B00")]
|
|
public sealed class RtcResources : DriverCategoryDeclaration
|
|
{
|
|
[IoPortRange(0, Default = 0x0070, Length = 0x02)]
|
|
public IoPortRange port1;
|
|
|
|
[IoIrqRange(1, Default = 0x08)]
|
|
public IoIrqRange irq1;
|
|
}
|
|
|
|
/// <remarks>
|
|
/// Class <c>RTClock</c> represents the system
|
|
/// Real-Time Clock. RTC chips in PCs are based on the
|
|
/// Motorola MC146818A. It provides timing resolution
|
|
/// of 1 second, but can generate periodic interrupts
|
|
/// more frequently.
|
|
/// </remarks>
|
|
[ CLSCompliant(false) ]
|
|
public sealed class RTClock
|
|
{
|
|
// Data registers
|
|
private const byte DS1287_SECONDS = 0x00;
|
|
private const byte DS1287_SECONDS_ALARM = 0x01;
|
|
private const byte DS1287_MINUTES = 0x02;
|
|
private const byte DS1287_MINUTES_ALARM = 0x03;
|
|
private const byte DS1287_HOURS = 0x04;
|
|
private const byte DS1287_HOURS_ALARM = 0x05;
|
|
private const byte DS1287_DAY_OF_WEEK = 0x06; // 1 is Sunday
|
|
private const byte DS1287_DAY_OF_MONTH = 0x07;
|
|
private const byte DS1287_MONTH = 0x08;
|
|
private const byte DS1287_YEAR = 0x09;
|
|
private const byte DS1287_USERDATA = 0x32; // Randomly chosen user reg.
|
|
// Control registers and masks
|
|
private const byte DS1287_A = 0x0a;
|
|
private const byte DS1287_A_UIP = 0x80; // Update Cycle Status
|
|
private const byte DS1287_A_DIVON = 0x20; // Osc and Freq Div on
|
|
private const byte DS1287_A_8KHZ = 0x03;
|
|
private const byte DS1287_A_4KHZ = 0x04;
|
|
private const byte DS1287_A_2KHZ = 0x05;
|
|
private const byte DS1287_A_1KHZ = 0x06;
|
|
private const byte DS1287_A_64HZ = 0x0a;
|
|
private const byte DS1287_A_2HZ = 0x0f;
|
|
private const byte DS1287_B = 0x0b;
|
|
private const byte DS1287_B_UTI = 0x80; // Update Transfer Inhibit
|
|
private const byte DS1287_B_PIE = 0x40; // Periodic Interrupt Enable
|
|
private const byte DS1287_B_24H = 0x20; // Alarm Interrupt Enable
|
|
private const byte DS1287_B_UIE = 0x10; // Update Cycle Inter. Enable
|
|
private const byte DS1287_B_SQWE = 0x08; // Square-Wave Enable
|
|
private const byte DS1287_B_DF = 0x04; // Data Format
|
|
private const byte DS1287_B_DF_BINARY = 0x04; // Binary
|
|
private const byte DS1287_B_DF_BCD = 0x00; // Binary Coded Decimal (BCD)
|
|
private const byte DS1287_B_HF = 0x02; // Hour Format
|
|
private const byte DS1287_B_HF_24H = 0x02; // 24-hour format
|
|
private const byte DS1287_B_HF_12H = 0x00; // 12-hour format
|
|
private const byte DS1287_B_DSE = 0x01; // Daylight Saving Enable
|
|
private const byte DS1287_C = 0x0c;
|
|
private const byte DS1287_C_UF = 0x10; // Update Event Flag
|
|
private const byte DS1287_C_AF = 0x20; // Alarm Event Flag
|
|
private const byte DS1287_C_PF = 0x40; // Periodic Event Flag
|
|
private const byte DS1287_C_INTF = 0x80; // Interrupt Request Flag
|
|
private const byte DS1287_D = 0x0d;
|
|
private const byte DS1287_D_VRT = 0x80; // Valid RAM and Time
|
|
|
|
private PnpConfig config;
|
|
private IoPort rtcadd;
|
|
private IoPort rtcdat;
|
|
|
|
private Apic apic;
|
|
private byte irq;
|
|
private byte interrupt;
|
|
internal volatile uint irqCount = 0;
|
|
|
|
private SpinLock rtcSpinLock; // Protects rtcBootTime and rtc update
|
|
private long rtcBootTime;
|
|
|
|
// Constructor
|
|
internal RTClock(PnpConfig config, Apic apic)
|
|
{
|
|
DebugStub.Print("RTClock: create\n");
|
|
|
|
// /pnp/08/03/01/PNP0B00 0003 cfg dis : ISA RTC Controller : AT RTC
|
|
// IRQ mask=0100 type=47
|
|
// I/O Port inf=01 min=0070 max=0070 aln=01 len=02 0070..0071
|
|
|
|
this.config = config;
|
|
this.irq = ((IoIrqRange)config.DynamicRanges[1]).Irq;
|
|
this.apic = apic;
|
|
this.rtcSpinLock = new SpinLock();
|
|
|
|
rtcadd = ((IoPortRange)config.DynamicRanges[0])
|
|
.PortAtOffset(0, 1, Access.ReadWrite);
|
|
rtcdat = ((IoPortRange)config.DynamicRanges[0])
|
|
.PortAtOffset(1, 1, Access.ReadWrite);
|
|
|
|
this.interrupt = Initialize();
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
private byte ReadRtc(byte addr)
|
|
{
|
|
IoResult result;
|
|
|
|
result = rtcadd.Write8NoThrow(addr);
|
|
DebugStub.Assert(IoResult.Success == result);
|
|
|
|
byte value;
|
|
result = rtcdat.Read8NoThrow(out value);
|
|
DebugStub.Assert(IoResult.Success == result);
|
|
return value;
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
private void WriteRtc(byte addr, byte val)
|
|
{
|
|
IoResult result;
|
|
|
|
result = rtcadd.Write8NoThrow(addr);
|
|
DebugStub.Assert(IoResult.Success == result);
|
|
|
|
result = rtcdat.Write8NoThrow(val);
|
|
DebugStub.Assert(IoResult.Success == result);
|
|
}
|
|
|
|
private byte Initialize()
|
|
{
|
|
// Disable and clear interrupts
|
|
if (Processor.SamplingEnabled()) {
|
|
WriteRtc(DS1287_A, DS1287_A_DIVON | DS1287_A_8KHZ);
|
|
}
|
|
else {
|
|
WriteRtc(DS1287_A, DS1287_A_DIVON | DS1287_A_64HZ);
|
|
}
|
|
|
|
WriteRtc(DS1287_B, DS1287_B_HF_24H | DS1287_B_DF_BCD);
|
|
ReadRtc(DS1287_C); // Clear any update bits
|
|
|
|
if ((ReadRtc(DS1287_D) & DS1287_D_VRT) == 0)
|
|
{
|
|
DebugStub.Print("RTClock weak or defective power source.\n");
|
|
}
|
|
|
|
rtcBootTime = PullRtcTime();
|
|
|
|
DebugStub.Print("RTClock::Start()\n");
|
|
|
|
// Enable and clear interrupts
|
|
// NB it may take 500ms for first interrupt to be generated.
|
|
WriteRtc(DS1287_A, DS1287_A_DIVON | DS1287_A_2HZ);
|
|
WriteRtc(DS1287_B, DS1287_B_HF_24H | DS1287_B_DF_BCD | DS1287_B_PIE | DS1287_B_SQWE);
|
|
ReadRtc(DS1287_C);
|
|
|
|
apic.EnableIrq(irq);
|
|
return apic.IrqToInterrupt(irq);
|
|
}
|
|
|
|
private int Log2(uint value)
|
|
{
|
|
int l = 0;
|
|
if ((value & 0xffff0000u) != 0) { l += 16; value >>= 16; }
|
|
if ((value & 0x0000ff00u) != 0) { l += 8; value >>= 8; }
|
|
if ((value & 0x000000f0u) != 0) { l += 4; value >>= 4; }
|
|
if ((value & 0x0000000cu) != 0) { l += 2; value >>= 2; }
|
|
if ((value & 0x0000000au) != 0) { l += 1; value >>= 1; }
|
|
return l;
|
|
}
|
|
|
|
internal bool SetFrequency(uint frequency)
|
|
{
|
|
if (frequency > 8192 || frequency < 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Processor.SamplingEnabled()) {
|
|
frequency = 8192;
|
|
}
|
|
|
|
int a = 0x20;
|
|
a |= (0xf - (Log2(frequency) - 1)) & 0xf;
|
|
WriteRtc(DS1287_A, (byte) a);
|
|
WriteRtc(DS1287_B, DS1287_B_HF_24H | DS1287_B_DF_BCD | DS1287_B_PIE | DS1287_B_SQWE);
|
|
ReadRtc(DS1287_C);
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Finalize()
|
|
{
|
|
apic.DisableIrq(irq);
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
public void ClearInterrupt()
|
|
{
|
|
byte status = ReadRtc(DS1287_C);
|
|
if ((status & DS1287_C_PF) != 0)
|
|
{
|
|
irqCount++;
|
|
}
|
|
apic.AckIrq(irq);
|
|
}
|
|
|
|
public byte Interrupt
|
|
{
|
|
[NoHeapAllocation]
|
|
get { return interrupt; }
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
[ System.Diagnostics.Conditional("SINGULARITY_MP") ]
|
|
[NoHeapAllocation]
|
|
private void AcquireLock()
|
|
{
|
|
rtcSpinLock.Acquire();
|
|
}
|
|
|
|
[ System.Diagnostics.Conditional("SINGULARITY_MP") ]
|
|
[NoHeapAllocation]
|
|
private void ReleaseLock()
|
|
{
|
|
rtcSpinLock.Release();
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
public long GetBootTime()
|
|
{
|
|
bool en = Processor.DisableInterrupts();
|
|
try {
|
|
AcquireLock();
|
|
long bootTime = rtcBootTime;
|
|
ReleaseLock();
|
|
return bootTime;
|
|
}
|
|
finally {
|
|
Processor.RestoreInterrupts(en);
|
|
}
|
|
}
|
|
|
|
public void SetRtcTime(long newRtcTime, long kernelTicks)
|
|
{
|
|
bool en = Processor.DisableInterrupts();
|
|
try {
|
|
AcquireLock();
|
|
long currentRtcTime = rtcBootTime + kernelTicks;
|
|
long delta = newRtcTime - currentRtcTime;
|
|
rtcBootTime = rtcBootTime + delta;
|
|
PushRtcTime(newRtcTime);
|
|
ReleaseLock();
|
|
}
|
|
finally {
|
|
Processor.RestoreInterrupts(en);
|
|
}
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
internal static byte BcdToHex(byte bcd)
|
|
{
|
|
return (byte) (10 * (bcd >> 4) + (bcd & 0x0f));
|
|
}
|
|
|
|
[NoHeapAllocation]
|
|
internal static byte HexToBcd(int hex)
|
|
{
|
|
int h = hex / 10;
|
|
return (byte) ((h << 4) | (hex - h * 10));
|
|
}
|
|
|
|
private long PullRtcTime()
|
|
{
|
|
for (uint iters = 0; iters < 1000000; iters++) {
|
|
bool iflag = Processor.DisableInterrupts();
|
|
|
|
try {
|
|
ReadRtc(DS1287_C); // Clear update flag if set
|
|
|
|
if ((ReadRtc(DS1287_A) & DS1287_A_UIP) != 0) {
|
|
// Update is in progress, try again
|
|
continue;
|
|
}
|
|
|
|
// There is no update
|
|
// pending. The specs suggest at least
|
|
// ~244us to read values (T_BUC)...
|
|
byte second = BcdToHex(ReadRtc(DS1287_SECONDS));
|
|
byte minute = BcdToHex(ReadRtc(DS1287_MINUTES));
|
|
byte hour = BcdToHex(ReadRtc(DS1287_HOURS));
|
|
byte day = BcdToHex(ReadRtc(DS1287_DAY_OF_MONTH));
|
|
byte month = BcdToHex(ReadRtc(DS1287_MONTH));
|
|
byte year = BcdToHex(ReadRtc(DS1287_YEAR));
|
|
byte century = BcdToHex(ReadRtc(DS1287_USERDATA));
|
|
|
|
// ...but we don't
|
|
// trust the specs, particularly as we may
|
|
// be running on emulated hardware. Retry
|
|
// if an update is pending or appears to
|
|
// have completed whilst reading the time.
|
|
if ((ReadRtc(DS1287_A) & DS1287_A_UIP) != 0 ||
|
|
(ReadRtc(DS1287_C) & DS1287_C_UF) != 0) {
|
|
continue;
|
|
}
|
|
|
|
DebugStub.Print("PullRtcTime: " +
|
|
"{0:d4}-{1:d2}-{2:d} {3:2}:{4:d2}:{5:d2}" +
|
|
"\n",
|
|
__arglist(100*century+year, month, day,
|
|
hour, minute, second));
|
|
|
|
DateTime d = new DateTime(century * 100 + year, month, day,
|
|
hour, minute, second);
|
|
return d.Ticks;
|
|
}
|
|
catch (ArgumentOutOfRangeException e) {
|
|
DebugStub.Print("PullRtcTime failed: {0}\n",
|
|
__arglist(e));
|
|
}
|
|
finally {
|
|
Processor.RestoreInterrupts(iflag);
|
|
}
|
|
}
|
|
return (new DateTime(2005, 1, 1, 0, 0, 0)).Ticks;
|
|
}
|
|
|
|
private void PushRtcTime(long dtTicks)
|
|
{
|
|
DateTime dt = new DateTime(dtTicks);
|
|
|
|
bool iflag = Processor.DisableInterrupts();
|
|
try {
|
|
byte saved = ReadRtc(DS1287_B);
|
|
|
|
// Set UTI bit to stop transfers between RTC
|
|
// bytes and user buffer.
|
|
WriteRtc(DS1287_B, (byte)(saved | DS1287_B_UTI));
|
|
// Write new values
|
|
WriteRtc(DS1287_SECONDS, HexToBcd(dt.Second));
|
|
WriteRtc(DS1287_MINUTES, HexToBcd(dt.Minute));
|
|
WriteRtc(DS1287_HOURS, HexToBcd(dt.Hour));
|
|
WriteRtc(DS1287_DAY_OF_MONTH, HexToBcd(dt.Day));
|
|
WriteRtc(DS1287_MONTH, HexToBcd(dt.Month));
|
|
|
|
int century = dt.Year / 100;
|
|
WriteRtc(DS1287_YEAR, HexToBcd(dt.Year - century*100));
|
|
WriteRtc(DS1287_USERDATA, HexToBcd(century));
|
|
// Clear UTI bit to enable transfers again
|
|
WriteRtc(DS1287_B, saved);
|
|
DebugStub.Print("PushRtcTime {3:2}:{4:d2}:{5:d2} {0}/{1}-{2:d4}\n",
|
|
__arglist(dt.Month, dt.Day,
|
|
100*century + dt.Year, dt.Hour,
|
|
dt.Minute, dt.Second));
|
|
}
|
|
finally {
|
|
Processor.RestoreInterrupts(iflag);
|
|
}
|
|
}
|
|
}
|
|
}
|