internal static IoApic [] CreateIOApics() { // Prefer to get the list of IoApics from the MADT Madt madt = AcpiTables.GetMadt(); if (madt != null) { ArrayList alist = madt.GetIoApics(); if (alist.Count > 0) { IoApic [] apics = new IoApic[alist.Count]; for (int i = 0; i < alist.Count; i++) { // Have to convert from a ...Hal.Acpi.IoApic into a Hal.IoApic: Microsoft.Singularity.Hal.Acpi.IoApic sourceEntry = (Microsoft.Singularity.Hal.Acpi.IoApic)alist[i]; IoApic destEntry = new IoApic(sourceEntry.Address, sourceEntry.InterruptBase); destEntry.SetId(sourceEntry.Id); apics[i] = destEntry; } DebugStub.Print("Created IoApics from MADT table\n"); return(apics); } } DebugStub.Print("Created IoApics from MpResources table table\n"); // Otherwise, create from Mp tables return(CreateFromMpResources()); }
public void Write(Bytes data) { if (tcpSession.CurrentState < TcpState.ESTABLISHED) { state = State.Closed; DebugStub.Print("Connection unexpectedly closed\n"); throw new Exception("Write: CantSend"); } int bytesToWrite = data.Length; int written = tcpSession.Send(data); if (written == -1) { state = State.Closed; // A -1 return value indicates the connection has been closed // underneath us while we were trying to write. throw new Exception("WriteData: CantSend"); } else if (written != bytesToWrite) { // This is unexpected; the current implementation always // blocks and writes as much data as is provided. throw new Exception("Unexpected partial write in TcpSession.WriteData"); } }
internal static void DebugPrint(string format, params object [] args) { DebugStub.Print("DhcpClient: {0}", DebugStub.ArgList( string.Format(format, args)) ); }
public override void DisableIrq(byte irq) { #if DEBUG_IO_APIC_IRQ_MASK DebugStub.Print("Disabling IRQ 0x{0:x}\n", __arglist(irq)); #endif foreach (IoApic ioApic in ioApics) { #if DEBUG_IO_APIC_IRQ_MASK DebugStub.Print("Found IoApic 0x{0:x}; interrupt base 0x{1:x}, entry count 0x{2:x}\n", __arglist(ioApic.GetId(), ioApic.InterruptBase, ioApic.RedirectionEntryCount)); #endif if ((ioApic.InterruptBase <= irq) && (irq < (ioApic.InterruptBase + ioApic.RedirectionEntryCount))) { #if DEBUG_IO_APIC_IRQ_MASK DebugStub.Print("Disabling IRQ 0x{0:x} as 0x{1:x} on ioApic 0x{2:x}\n", __arglist(irq, irq - ioApic.InterruptBase, ioApic.GetId())); #endif ioApic.SetEntryMask(irq - ioApic.InterruptBase, true); break; } } #if DEBUG_IO_APIC_IRQ_MASK PrintIoApics(); #endif }
public static void PrintApic(IoApic ioApic) { DebugStub.Print("Io Apic\n"); DebugStub.Print(" Id: {0:x2} Version: {1:x4} ArbitrationId: {2:x2}\n", __arglist( ioApic.GetId(), ioApic.GetVersion(), ioApic.GetArbitrationId())); for (uint i = 0; i < ioApic.RedirectionEntryCount; i++) { RedirectionEntry e = ioApic.GetRedirectionEntry(i); IoBits ib = (IoBits)((int)e.IoBits & ~(int)IoBits.DelModMask); DebugStub.Print(" IoRedTbl[{0:x2}]" + "Dst: {1:x2} IntVec: {2:x2} Control: {3} {4} {5} {6} {7} {8}" + "Delivery Mode ", __arglist( i, e.Destination, e.InterruptVector, ((ib & IoBits.DstLogical) != 0) ? "Logical" : "Physical", ((ib & IoBits.IrqMask) != 0) ? "Masked" : "Unmasked", ((ib & IoBits.TriggerModeMask) != 0) ? "Level" : "Edge", ((ib & IoBits.RemoteIRR) != 0) ? "Accept" : "Recv", ((ib & IoBits.IntPolMask) != 0) ? "Hi active" : "Lo active", ((ib & IoBits.DeliveryStatus) != 0) ? "Pending" : "Idle")); DescribeModMask(e.IoBits); } }
// Constructor internal RTClockApic(PnpConfig config, Apic apic) { int cpuId; Microsoft.Singularity.Hal.Platform p = Microsoft.Singularity.Hal.Platform.ThePlatform; cpuId = p.ApicId; 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(SpinLock.Types.RTClock); rtcadd = ((IoPortRange)config.DynamicRanges[0]) .PortAtOffset(0, 1, Access.ReadWrite); rtcdat = ((IoPortRange)config.DynamicRanges[0]) .PortAtOffset(1, 1, Access.ReadWrite); if (cpuId == 0) { this.interrupt = Initialize(); DebugStub.Print("RTClock: interrupt {0:x2}\n", __arglist(this.interrupt)); } }
public Packet Pop() { { if (this.length < 1) { DebugStub.Print("ACK! packetfifo empty??\n"); throw new Exception(); } Packet packet; int index = (this.Capacity + this.head - this.length) % this.Capacity; if (index > packets.Length || index < 0) { DebugStub.Print("ACK index {0}\n", packets.Length); DebugStub.Print("ACK plength {0}\n", packets.Length); DebugStub.Print("ACK head {0}\n", this.head); DebugStub.Print("ACK length {0}\n", this.length); DebugStub.Print("ACK capacity {0}\n", this.Capacity); throw new Exception(); } packet = packets[index]; this.packets[index] = null; this.length--; return(packet); } }
//push a single packet onto the ring void IAdapter.PopulateTxRing(Bytes header, Bytes data) { try { PacketFifo txFree = this.txFreeFifo.Acquire(); PacketFifo txToDevice = this.txFifo.Acquire(); DebugPrint("populate tx ring\n"); try { Packet packet = txFree.Pop(); packet.SetFragment(0, header); packet.SetFragment(1, data); txToDevice.Push(packet); } finally { this.txFreeFifo.Release(txFree); this.txFifo.Release(txToDevice); } } catch (Exception e) { DebugStub.Print("Populate tx ring failed?? {0}\n", DebugStub.ArgList(e)); DebugStub.Break(); } //When to exchange? //how do we best manage the tradeoff of throughput and latency? //to begin let's just send one at a time. //I think i'd rather have another thread.... using (thisLock.Lock()) { TxExchange(); } }
private void TxExchange() { int toCount = 0; int fromCount = 0; NicDeviceContract /*.Imp*/ imp = (NicDeviceContract)nicChannel.Acquire(); try { PacketFifo src = this.txFifo.Acquire(); PacketFifo free = this.txFreeFifo.Acquire(); toCount = src.Count; try { src = imp.GiveTxPacketsToDevice(src); fromCount = src.Count; free.Push(src); } finally { this.txFreeFifo.Release(free); this.txFifo.Release(src); } } catch (Exception e) { DebugStub.Print("TxExchange FAILED arg {0}\n", DebugStub.ArgList(e.ToString())); DebugStub.Break(); } finally { nicChannel.Release(imp); } DebugPrint("TxExchange out: {0} in: {1}\n", toCount, fromCount); }
uint capabilities; // bits 0-31 at offset 0 internal Hpet(PnpConfig config) { int cpuId; Microsoft.Singularity.Hal.Platform p = Microsoft.Singularity.Hal.Platform.ThePlatform; cpuId = p.ApicId; this.config = config; IoMemoryRange imr = (IoMemoryRange)config.DynamicRanges[0]; this.region = imr.MemoryAtOffset(0, (int)imr.Length.ToUInt32(), Access.ReadWrite); capabilities = region.Read32(0x00); periodFs = region.Read32(0x04); if (cpuId == 0) { DebugStub.Print("new Hpet writing regions\n"); // Disable interrupts on timers for (uint i = 0; i <= MaxCounterIndex; i++) { DisableInterrupt(i); } uint gc = region.Read32(0x10) & ~3u; // Clear legacy bits region.Write32(0x10, gc | 1); // Enable main counter } }
private static void DisplayResults(ulong tscHz, int i8254Hz) { DebugStub.Print("TSC measured at {0} MHz\n", __arglist((int)(tscHz / 1000000))); DebugStub.Print("i8254 measured at {0} Hz\n", __arglist(i8254Hz)); }
private Packet MakePacketFromDescriptor(DmaMemory mem, ulong controlBits) { PacketFifo inDevPkts = rxPacketsInDevice.Acquire(); Packet packet = inDevPkts.Pop(); int length = (int)((controlBits & RxDescriptor.LENGTH_MASK) >> RxDescriptor.LENGTH_SHIFT); uint stat_err = (uint)((controlBits & RxDescriptor.ERR_STAT_MASK) >> RxDescriptor.ERR_STAT_SHIFT); // can't deal with fragments yet if ((stat_err & RxErrStatFields.END_OF_PACKET) == 0) { INucleusCalls.DebugPrintHex(40, 0xd0); DebugStub.Print("FRAGMENT\n"); throw new Exception(); } //DebugStub.Assert((stat_err & RxErrStatFields.END_OF_PACKET) != 0); //DebugStub.Assert(packet.GetFragmentVirtualAddress(0) == fragmentVirtAddr); packet.FromDeviceFlags = GetRecvPktFlags(stat_err); packet.SetFragment(0, mem.BytesRef(0, length)); rxPacketsInDevice.Release(inDevPkts); return(packet); }
internal static void CpuCycleCounter(PMTimer pmTimer) { uint pmLast = pmTimer.Value; ulong tscLast = Processor.CycleCount; uint pmLimit = PMTimer.FrequencyHz / 15; uint pmAccum = 0; ulong tscNow = 0; // Initial measurements tscLast = Processor.CycleCount; pmLast = pmTimer.Value; // Measurement loop do { tscNow = Processor.CycleCount; uint pmNow = pmTimer.Value; pmAccum += PmDelta(pmNow, pmLast); pmLast = pmNow; } while (pmAccum < pmLimit); ulong tscHz = PMTimer.FrequencyHz * (tscNow - tscLast) / pmAccum; DebugStub.Print("Cpu{0}: TSC frequency {1} Hz\n", __arglist(Processor.CurrentProcessor.Id, tscHz)); Processor.CyclesPerSecond = tscHz; }
internal static void ApicTimer(PMTimer pmTimer, ApicTimer apicTimer) { apicTimer.SetDivisor(1); apicTimer.SetOneShot(); apicTimer.SetInterruptEnabled(false); apicTimer.SetInitialCount(~0u); uint apicLast = apicTimer.Value; uint pmLast = pmTimer.Value; uint pmLimit = PMTimer.FrequencyHz / 15; uint pmAccum = 0; uint apicNow = 0; // Initial measurements apicLast = apicTimer.Value; pmLast = pmTimer.Value; do { apicNow = apicTimer.Value; uint pmNow = pmTimer.Value | 0xff000000; pmAccum += PmDelta(pmNow, pmLast); pmLast = pmNow; } while (pmAccum < pmLimit); ulong apicHz = PMTimer.FrequencyHz * (ulong)(apicLast - apicNow) / pmAccum; DebugStub.Print("Cpu{0}: APIC timer frequency {1} Hz\n", __arglist(Processor.CurrentProcessor.Id, apicHz)); apicTimer.SetBusFrequency((uint)apicHz); }
public byte Initialize(byte baseVector) { DebugStub.Print("Pic.Initializing IRQs at interrupt {0:x2}\n", __arglist(baseVector)); this.baseVector = baseVector; irqMask = unchecked ((ushort)~PIC_I_PIC1); // Set ICW1 (must be followed by ICW2, ICW3, and ICW4). // 00010001b - 8-byte,cascaded,triggered,w/ICW4 pic1CtrlPort.Write8(0x11); pic0CtrlPort.Write8(0x11); // Set ICW2..ICW3 (must follow ICW1) pic1MaskPort.Write8((byte)(baseVector + 8)); pic0MaskPort.Write8(baseVector); pic1MaskPort.Write8(0x02); // Cascaded interrupt number pic0MaskPort.Write8(0x04); // Cascaded interrupt bit. pic1MaskPort.Write8(1); // End of Interrupt pic0MaskPort.Write8(1); pic1CtrlPort.Write8(0x20); // EOI pic0CtrlPort.Write8(0x20); // EOI MaskAll(); return(PIC_VECTORS); }
public override void AckIrq(byte irq) { DebugStub.Assert(Processor.InterruptsDisabled()); #if PIC_DEBUG DumpRegisters(); #endif // Mark the IRQ as activated and mask it #if DEBUG_INTERRUPTS DebugStub.Print("Int{0:x2} Acked, Mask={1:x4}\n", __arglist(irq + baseVector, irqMask)); #endif // Quite the interrupt controller. IoResult result; if (irq >= 8) { result = pic1CtrlPort.Write8NoThrow(PIC_NS_EOI); DebugStub.Assert(IoResult.Success == result); } result = pic0CtrlPort.Write8NoThrow(PIC_NS_EOI); DebugStub.Assert(IoResult.Success == result); #if PIC_DEBUG DumpRegisters(); #endif }
private void Unmask(byte irq) { DebugStub.Assert(Processor.InterruptsDisabled()); ushort newMask = (ushort)(irqMask & ~(1 << irq)); if (newMask != irqMask) { #if DEBUG_DISPATCH_IO DebugStub.WriteLine("-- Unmask IRQs: old={0:x4} new={1:x4}", __arglist(irqMask, newMask)); #endif irqMask = newMask; IoResult result; result = pic1MaskPort.Write8NoThrow((byte)(irqMask >> 8)); DebugStub.Assert(IoResult.Success == result); result = pic0MaskPort.Write8NoThrow((byte)(irqMask & 0xff)); DebugStub.Assert(IoResult.Success == result); #if PIC_DEBUG byte mask0; result = pic0MaskPort.Read8(out mask0); DebugStub.Assert(IoResult.Success == result); byte mask1; result = pic1MaskPort.Read8(out mask1); DebugStub.Assert(IoResult.Success == result); DebugStub.Print("PIC Mask: {0:x2}{1:x2}\n", __arglist(mask1, mask0)); #endif } }
private void PushRtcTime(DateTime dt) { bool iflag = Processor.DisableInterrupts(); byte saved = ReadRtc(DS1287_B); try { // 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(9, HexToBcd(dt.Year - century * 100)); WriteRtc(DS1287_YEAR, HexToBcd(dt.Year - century * 100)); WriteRtc(DS1287_USERDATA, HexToBcd(century)); // Clear UTI bit to enable transfers again 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 { WriteRtc(DS1287_B, saved); Processor.RestoreInterrupts(iflag); } }
public override void ClearInterrupt() { #if RTC_NO_GO DebugStub.Print("Unwanted RTC interrupt! (b = {0})\n", __arglist(ReadRtc(DS1287_B))); return; #endif // RTC_NO_GO byte status = ReadRtc(DS1287_C); if ((status & 0x40) != 0x40) { // We may get Update-Ended interrupts even though we've // not requested them. pic.AckIrq(irq); return; } ClockLogger.AddEntry(4, rps, timer); rps.pitLastClock = timer.Timer2Read(); rps.upTime += InterruptGapTicks; ClockLogger.AddEntry(5, rps, timer); irqCount++; if (timer.InterruptPending == false) { // This is to keep time progressing if the user has // not set an interrupt timer.SetKeepAliveInterrupt(); } pic.AckIrq(irq); // Invalidate TSC snapshot to force clock synchronization this.tscSnapshotValid = false; }
internal byte Initialize() { DebugStub.Print("RTClock: initialize\n"); rps = timer.rps; // Turn oscillator on, but disable and clear interrupts if (Processor.SamplingEnabled()) { WriteRtc(DS1287_A, DS1287_A_DIVON | DS1287_A_SAMPLING_HZ); } else { WriteRtc(DS1287_A, DS1287_A_DIVON | DS1287_A_64HZ); } WriteRtc(DS1287_B, DS1287_B_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().Ticks; // Enable and clear interrupts // NB it may take 500ms for first interrupt to be generated. pic.EnableIrq(irq); return(pic.IrqToInterrupt(irq)); }
public Bytes GetNextBuffer(out int start, out int length) { if (this.Empty) { start = -1; length = -1; return(null); } if (this.currentTxBuff == null) { this.currentTxBuff = this.listHead.next; this.currentTxTotalOffset = 0; this.currentTxBufferOffset = this.currentTxBuff.startOffset; } else { this.currentTxBuff = this.currentTxBuff.next; this.currentTxBufferOffset = this.currentTxBuff.startOffset; if (this.currentTxBuff == this.listTail) { DebugStub.Print("GetBuffer: Empty list???\n"); DebugStub.Break(); start = -1; length = -1; return(null); } } start = (int)this.currentTxBuff.startOffset; length = (int)this.currentTxBuff.length; return(this.currentTxBuff.data); }
static ClockLogger() { InitializeEntries(); #if LOG_CLOCK DebugStub.Print("Initializing ClockLogger.\n"); #endif // LOG_CLOCK }
static void DumpEntries() { DebugStub.Print("# Clock column 1 who\n"); DebugStub.Print("# Clock column 2 time in cpu cycles\n"); DebugStub.Print("# Clock column 3 time from clock\n"); DebugStub.Print("# Clock column 4 pitLastClock\n"); DebugStub.Print("# Clock column 5 pitNow\n"); DebugStub.Print("# Clock column 6 upTime\n"); DebugStub.Print("# Clock column 7 currentTime\n"); DebugStub.Print("# Clock column 8 cookie\n"); DebugStub.Print("# Clock column 9 record number\n"); for (int i = 0; i != currentRecord; i++) { DebugStub.Print("Clock {0:d6} {1:d6} {2} {3} {4} {5} {6} {7}\n", __arglist( ToMicros(entries[i].when, entries[0].when, Processor.CyclesPerSecond), ToMicros(entries[i].currentTime, 0, 10000000), entries[i].pitLastClock, entries[i].pitNow, entries[i].upTime, entries[i].currentTime, entries[i].cookie, i)); } }
private void InitializeRouteableEntries() { DebugStub.Print("Initializing Apic routeable entries\n"); // Initialize entries that may not be part of MP set // configuration, but might be utilizable via a // programmable interrupt routing on PCI-LPC bridge // or elsewhere. byte irq = 16; IoBits stdPciBits = (IoBits.DstPhysical | IoBits.DelModFixed | IoBits.IrqMask | IoBits.IntPolActiveLow | IoBits.TriggerModeLevel); for (int id = 0; id < ioApics.Length; id++) { uint start = (id == 0) ? 16u : 0u; uint end = ioApics[id].RedirectionEntryCount; for (uint index = start; index < end; index++) { RedirectionEntry re = new RedirectionEntry(this.Id, stdPciBits, IrqToInterrupt(irq)); ioApics[id].SetRedirectionEntry(index, ref re); irq++; #if PRINT_IO_APICS DebugStub.Print("Added routeable entry for apic 0x{0:x}: IRQ 0x{1:x} => 0x{2:x}\n", __arglist(id, irq, IrqToInterrupt(irq))); #endif } } maxIrq = (byte)(irq - 1); PrintIoApics(); }
internal static void DebugPrint(string format, params object [] arguments) { DebugStub.Print("ARPModule: {0}", __arglist( string.Format(format, arguments)) ); }
internal static void DebugPrint(string format, params object [] arguments) { DebugStub.Print("UDP: {0}", DebugStub.ArgList( string.Format(format, arguments)) ); }
internal void SwitchToHpetClock(HpetClock hc) { // Change rt clock interrupt frequency to appropriate // rate for HPET main clock. rtClock.SetFrequency(HpetClock.UpdateFrequency(hc.Hpet)); hpetClock = hc; DebugStub.Print("Hal switching to HpetClock.\n"); }
internal static void Run(HalClockNull clock, TimerOmap3430 gpTimer1) { DebugStub.Print("CLOCK CALIBRATION NOT ATTEMPTED.\n"); // hacked, should calibrate Processor.CyclesPerSecond = 687 * 1000 * 1000; // MPU runs @ 687Mhz in OPP1 gpTimer1.SetTicksPerSecond(32768); return; }
internal static int AppMain(Parameters !config) { DebugStub.Print("About to write to console\n"); Console.WriteLine("Hello World!"); DebugStub.Print("Wrote to console\n"); return(0); }
internal static void ParseMpTables() { UIntPtr mpFloat = GetMpFloatBase(); if (mpFloat == UIntPtr.Zero) { DebugStub.Print("MP Floating Pointer Structure not found.\n"); return; } mpFloatRegion = IoMemory.MapPhysicalMemory(mpFloat, new UIntPtr(16), true, false); FloatingPointer = MpFloatingPointer.Parse(mpFloatRegion); if (FloatingPointer == null) { DebugStub.Print("Failed to parse MP Floating Pointer " + "Structure.\n"); return; } if (FloatingPointer.MpConfTablePresent) { mpConfTableRegion = IoMemory.MapPhysicalMemory( new UIntPtr(FloatingPointer.ConfTableBase), new UIntPtr(0x2c), true, false); DebugStub.Print("Found MP Conf Table\n"); ConfTable = MpConfTable.Parse(mpConfTableRegion); if (ConfTable == null) { DebugStub.Print("Failed to parse MP Configuration table.\n"); } IoMemory mpResourceRegion = IoMemory.MapPhysicalMemory( new UIntPtr(FloatingPointer.ConfTableBase + 0x2c), new UIntPtr(ConfTable.BaseTableLength - 0x2c), true, false); DebugStub.Print("Parsing MP Conf Table Resources\n"); MpResources.Parse(mpResourceRegion, ConfTable.BaseTableLength - 0x2c, ConfTable.EntryCount); } else { DebugStub.Print("MP Configuration table not present.\n"); DebugStub.Print("MP Floating Pointer features: " + "{0:x8} {1:x8} {2:x8} {3:x8} {4:x8}\n", __arglist( FloatingPointer.Feature[0], FloatingPointer.Feature[1], FloatingPointer.Feature[2], FloatingPointer.Feature[3], FloatingPointer.Feature[4])); } }