/// <summary>
/// Initialize the Machine
/// </summary>
public static void Setup()
{
Multiboot.Setup();
PIC.Setup();
IDT.Setup();
PageFrameAllocator.Setup();
PageTable.Setup();
VirtualPageAllocator.Setup();
GC.Setup();
Scheduler.Setup();
Serial.SetupPort(Serial.COM1);
var _hal = new Hardware();
if (VBEDisplay.InitVBE(_hal))
{
ScreenManager.Setup();
ScreenManager.Add(new BootScreen());
ScreenManager.Add(new TestScreen());
ScreenManager.ChangeScreen(ScreenIds.Boot);
}
Native.Hlt();
}
private void Cut()
{
a = 0;
foreach (int id in CDB.cards.Keys)
{
if (stop == false)
{
a++;
PIC.CutJPG(path1, id, CDB.cards[id].type, path2, SET.Length, SET.Length);
progressBar1.Invoke(pb1);
label1.Invoke(lb1);
}
else
{
break;
}
}
if (stop == true)
{
MessageBox.Show("已经取消！");
}
else
{
stop = true;
MessageBox.Show("裁剪完成。\n文件在" + path2);
}
this.Invoke(fm);
}
public RegisterMapForm(PIC.Register.RegisterFileMap _registerFileMap)
{
InitializeComponent();
registerFileMap = _registerFileMap;
createMap();
createSpecialValueView();
}
// Bootstrap is a class designed only to get the essentials done.
// ie the stuff needed to "pre boot". Do only the very minimal here.
// IDT, PIC, and Float
// Note: This is changing a bit GDT (already) and IDT are moving to a real preboot area.
public static void Init()
{
// Drag this stuff in to the compiler manually until we add the always include attrib
INTs.Dummy();
PIC = new PIC();
CPU.UpdateIDT(true);
/* TODO check using CPUID that SSE2 is supported */
CPU.InitSSE();
/*
* We liked to use SSE for all floating point operation and end to mix SSE / x87 in Cosmos code
* but sadly in x86 this resulte impossible as Intel not implemented some needed instruction (for example conversion
* for long to double) so - in some rare cases - x87 continue to be used. I hope passing to the x32 or x64 IA will solve
* definively this problem.
*/
CPU.InitFloat();
header = (Multiboot.Header *)Multiboot.GetMBIAddress();
modeinfo = (Core.VBE.ModeInfo *)header->vbeModeInfo;
controllerinfo = (Core.VBE.ControllerInfo *)header->vbeControlInfo;
// Managed_Memory_System.ManagedMemory.Initialize();
// Managed_Memory_System.ManagedMemory.SetUpMemoryArea();
}
string ConvertToDisplayValue(FieldValue fieldValue)
{
string displayValue = "";
if (fieldValue.IsNull)
{
displayValue = displayField.NullDisplay;
}
else
{
int ctlIndex = view.DataSourceViewDefinition.TaskDataSource.DataSourceDefinition.Id.CtlIdx;
PIC fieldPicture = new PIC(displayField.Picture, (StorageAttribute)displayField.Attr, ctlIndex);
displayValue = DisplayConvertor.Instance.mg2disp(fieldValue.Value.ToString(), "", fieldPicture, ctlIndex, false);
displayValue = displayValue.Trim();
}
// Empty values should be displayed as a single blank character so that they will
// be selectable by pressing the 'space key'.
// This is consistent with the behavior on the server as defined in choiceinp.cpp/PrepareDisplayElement_U
// and RT::vew_fetch_data_ctrl.
if (String.IsNullOrEmpty(displayValue))
{
displayValue = " ";
}
return(displayValue);
}
public override void Execute(PIC Pic, BytecodeLine Line)
{
int Command = Line.Command;
int RegAddress = Command & 0x7F;
bool D = (Command & 0x80) != 0;
byte Value = Pic.RegisterMap.Get(RegAddress);
Value = Calculate(Pic, Line, Value);
if (AffectsZFlag)
{
Pic.RegisterMap.ZeroBit = Value == 0;
}
if (D)
{
Pic.RegisterMap.Set(Value, RegAddress);
}
else
{
Pic.WRegister.Value = Value;
}
Pic.RegisterMap.ProgrammCounter++;
}
public static void Setup()
{
Screen.Clear();
Screen.Color = 0x0E;
Screen.SetCursor(24, 0);
Screen.Write('1');
Multiboot.Setup();
Screen.SetCursor(24, 1);
Screen.Write('2');
PIC.Setup();
Screen.SetCursor(24, 2);
Screen.Write('3');
GDT.Setup();
Screen.SetCursor(24, 3);
Screen.Write('4');
IDT.Setup();
Screen.SetCursor(24, 4);
Screen.Write('5');
PageFrameAllocator.Setup();
Screen.SetCursor(24, 5);
Screen.Write('6');
PageTable.Setup();
Screen.SetCursor(24, 6);
Screen.Write('7');
VirtualPageAllocator.Setup();
Screen.SetCursor(24, 7);
Screen.Write('8');
Screen.SetCursor(24, 8);
ProcessManager.Setup();
Screen.Write('9');
Screen.SetCursor(24, 9);
TaskManager.Setup();
Screen.Write('A');
Screen.SetCursor(24, 10);
}
static void Main(string[] args)
{
List <String> HexCode;
List <picWord> RAM;
Init();
if (args.Length < 1)
{
HexCode = readHex("flash.hex");
}
else
{
HexCode = readHex(args[0]);
}
//NoLines = HexCode.Length;
RAM = decompile(HexCode);
RAM.Sort();
foreach (var line in RAM)
{
Console.WriteLine(line.ToString()); // Display the memory mapped dissasembly + data
}
Console.ReadKey();
PIC test = new PIC("lab11.hex");
Console.ReadKey();
}
/// <summary>
/// Make copy of validation details,
/// copy constructor
/// </summary>
public ValidationDetails(ValidationDetails vd) : this()
{
_oldvalue = vd.getOldValue();
_val = vd._val;
_range = vd.getRange();
_control = vd.getControl();
_validationFailed = false;
if (vd._pictureReal != null)
{
_pictureReal = new StringBuilder(vd._pictureReal.ToString());
}
if (vd._pictureEnable != null)
{
_pictureEnable = new StringBuilder(vd._pictureEnable.ToString());
}
if (vd.getDiscreteRangeValues() != null)
{
_discreteRangeValues = vd.CloneDiscreteRangeValues();
}
if (vd.getContinuousRangeValues() != null)
{
_continuousRangeValues = vd.CloneContinuousRangeValues();
}
_picData = vd.getPIC();
_isNull = vd.getIsNull();
}
public static Bitmap Setjpg(string gpath, bool yulan, int id, int leng)
{
string jpgfile = gpath + "pics\\" + id.ToString() + ".jpg";
if (File.Exists(jpgfile))
{
if (yulan == true)
{
if (CDB.cards.ContainsKey(id))
{
return(PIC.CutJPG(gpath, id, CDB.cards[id].type, leng, leng));
}
}
else
{
return(PIC.GetBitmap(jpgfile));
}
}
else
{
jpgfile = "./data/Images/cover.jpg";
if (File.Exists(jpgfile))
{
return(PIC.GetBitmap(jpgfile));
}
}
return(null);
}
private void MenuItem_Open_Click(object sender, RoutedEventArgs e)
{
Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog();
ofd.DefaultExt = ".hex";
ofd.Filter = "HEX Files (*.hex)|*.hex|All Files (*.*)|*.*";
Nullable <bool> selected = ofd.ShowDialog();
if (selected == true)
{
//lstISA.Items.Clear();
lstHex.Items.Clear();
string fname = ofd.FileName;
StreamReader sr = new StreamReader(ofd.OpenFile());
while (!sr.EndOfStream)
{
lstHex.Items.Add(sr.ReadLine());
}
pic = new PIC(fname);
ISA = pic.decompile();
lstISA.ItemsSource = ISA;
//foreach (var x in ISA)
//{
// lstISA.Items.Add(x);
//}
mnuRun.IsEnabled = true;
CLK.Interval = pic.getclkInterval() / 2;
CLK.Elapsed += CLK_Elapsed;
CLK.AutoReset = true;
lblStatus.DataContext = pic.getCurrent();
}
}
public Parser(PIC _pic)
{
this.pic = _pic;
this.registerFileMap = pic.getRegisterFileMap();
this.programMemory = pic.getProgramMemory();
this.operationStack = pic.getOperationStack();
this.programCounter = pic.getProgramCounter();
}
public Timer0(Register.RegisterFileMap _registerFileMap, PIC _pic)
{
tmr0Register = _registerFileMap.getAdapter(Register.RegisterConstants.TMR0_ADDRESS);
optionRegister = _registerFileMap.getAdapter(Register.RegisterConstants.OPTION_REG_BANK1_ADDRESS);
registerFileMap = _registerFileMap;
internalCounter = 0;
timerHandler = new Timer0Handler(_registerFileMap, this, _pic);
}
public override byte Calculate(PIC Pic, Data.BytecodeLine Line, byte Value)
{
int NewValue = Pic.WRegister.Value + Value;
Pic.RegisterMap.CarryBit = NewValue > 0xFF;
Pic.RegisterMap.DigitalCarryBit = ((Pic.WRegister.Value & 0xF) + (Value & 0xF)) > 0xF;
return((byte)NewValue);
}
public override byte Calculate(PIC Pic, Data.BytecodeLine Line, byte Value)
{
int NewValue = Value << 1;
NewValue = NewValue + (Pic.RegisterMap.CarryBit ? 1 : 0);
Pic.RegisterMap.CarryBit = (NewValue & 0x100) != 0;
return((byte)NewValue);
}
public override bool Calculate(PIC Pic, Data.BytecodeLine Line, int Literal)
{
int NewValue = Pic.WRegister.Value ^ Literal;
Pic.RegisterMap.ZeroBit = NewValue == 0;
Pic.WRegister.Value = (byte)NewValue;
return(true);
}
public override void Execute(PIC Pic, Data.BytecodeLine Line)
{
int Command = Line.Command;
int RegAddress = Command & 0x7F;
Pic.RegisterMap.Set(Pic.WRegister.Value, RegAddress);
Pic.RegisterMap.ProgrammCounter++;
}
public override void Execute(PIC Pic, Data.BytecodeLine Line)
{
int NewAddress = Line.Command & 0x7FF;
int PC = Pic.RegisterMap.ProgrammCounter;
Pic.Stack.Push(PC + 1);
Pic.RegisterMap.ProgrammCounter = NewAddress;
}
public override bool Calculate(PIC Pic, Data.BytecodeLine Line, int Literal)
{
int NewValue = Literal - Pic.WRegister.Value;
Pic.RegisterMap.CarryBit = NewValue > 0;
Pic.RegisterMap.DigitalCarryBit = ((Pic.WRegister.Value & 0xF) + (Literal & 0xF)) > 0xF;
Pic.RegisterMap.ZeroBit = NewValue == 0;
Pic.WRegister.Value = (byte)NewValue;
return(true);
}
public override byte Calculate(PIC Pic, Data.BytecodeLine Line, byte Value)
{
int CarryValue = Pic.RegisterMap.CarryBit ? 1 : 0;
int NewCarry = Value & 0x1;
int NewValue = CarryValue << 8 + Value >> 1;
Pic.RegisterMap.CarryBit = NewCarry != 0;
return((byte)NewValue);
}
public override void Execute(PIC Pic, BytecodeLine Line)
{
int Command = Line.Command;
int Literal = Command & 0xFF;
if (Calculate(Pic, Line, Literal))
{
Pic.RegisterMap.ProgrammCounter++;
}
}
public ControlForm(PIC.PIC _pic)
{
InitializeComponent();
this.pic = _pic;
pic.registerExecutionStateListener(onPicExecutionChange);
Disposed += delegate { pic.unregisterExecutionStateListener(onPicExecutionChange); };
frequencyTextBox.Text = "4";
frequencyUnitBox.SelectedIndex = 2;
}
/// <summary> convert numbers to our secret format
/// </summary>
/// <param name="fileName"></param>
private static String Encode(String numStr, StorageAttribute attr, String picStr)
{
PIC pic = new PIC(picStr, attr, 0);
NUM_TYPE num_type = new NUM_TYPE(numStr, pic, 0);
String encoded_num = num_type.toXMLrecord();
encoded_num = Base64.encode(RecordUtils.byteStreamToString(encoded_num), ClientManager.Instance.getEnvironment().GetEncoding());
return(XmlParser.escape(encoded_num));
}
public Timer0(PIC Pic)
{
this.Pic = Pic;
Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_PORT_A).DataChanged += PortA_DataChanged;
Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_TIMER_ADDRESS).DataChanged += Timer0_DataChanged;
PortALastValue = Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_PORT_A).Value & 0x4;
Reset();
}
/// <summary>
/// Switch to a specific thread.
/// This method will not return!
/// </summary>
public static unsafe void SwitchToThread(int threadID)
{
var thread = Threads[threadID];
var proc = thread.Process;
if (KConfig.Log.TaskSwitch)
{
KernelMessage.WriteLine("Switching to Thread {0}. StackState: {1:X8}", threadID, (uint)thread.StackState);
}
//Assert.True(thread != null, "invalid thread id");
thread.Ticks++;
SetThreadID(threadID);
PIC.SendEndOfInterrupt((int)KnownInterrupt.ClockTimer);
thread.Status = ThreadStatus.Running;
if (thread.StackState == null)
{
DumpStats();
KernelMessage.WriteLine("threadID: {0}", threadID);
Debug.Break();
}
thread.StackState->Stack.EFLAGS |= X86_EFlags.InterruptEnableFlag;
if (proc.PageTable != PageTable.KernelTable)
{
Debug.Nop();
}
uint pageDirAddr = proc.PageTable.GetPageTablePhysAddr();
//KernelMessage.WriteLine("PageDirAddr: {0:X8}", pageDirAddr);
uint stackStateAddr = (uint)thread.StackState;
uint dataSelector = thread.DataSelector;
if (!thread.User)
{
thread.StackState = null; // just to be sure
}
GDT.Tss->ESP0 = thread.KernelStackBottom;
if (thread.Debug)
{
Native.Nop();
}
GDT.SetThreadStorageSegmentBase(thread.ThreadLocalStorageBaseAddr);
InterruptReturn(stackStateAddr, pageDirAddr, dataSelector, KnownSegments.UserThreadStorage);
}
public override void Execute(PIC Pic, Data.BytecodeLine Line)
{
int Command = Line.Command;
byte NewValue = 0;
Pic.RegisterMap.ZeroBit = true;
Pic.WRegister.Value = NewValue;
Pic.RegisterMap.ProgrammCounter++;
}
public static void Init()
{
uint divisor = (1193180 * 10) / 1000; /* Calculate our divisor */ //10ms
Native.Out8(0x43, 0x36); /* Set our command byte 0x36 */
Native.Out8(0x40, (byte)(divisor & 0xFF)); /* Set low byte of divisor */
Native.Out8(0x40, (byte)(divisor >> 8)); /* Set high byte of divisor */
mCurrentTask = 0;
PIC.ClearMask(0);
}
public override void Execute(PIC Pic, Data.BytecodeLine Line)
{
int Command = Line.Command;
int RegAddress = Command & 0x7F;
byte NewValue = 0;
Pic.RegisterMap.ZeroBit = true;
Pic.RegisterMap.Set(NewValue, RegAddress);
Pic.RegisterMap.ProgrammCounter++;
}
public EEPROM(PIC Pic)
{
this.Pic = Pic;
EEAddr = Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_EEADDR_ADDRESS);
EEData = Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_EEDATA_ADDRESS);
EECon1 = Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_EECON1_ADDRESS);
EECon2 = Pic.RegisterMap.GetAdapter(Register.RegisterFileMap.REG_EECON2_ADDRESS);
EECon1.DataChanged += EECon1_DataChanged;
EECon2.DataChanged += EECon2_DataChanged;
}
/// <summary> convert numbers from our secret format
/// </summary>
/// <param name="fileName"></param>
private static String Decode(String numStr, StorageAttribute attr, String picStr)
{
String decoded_num = XmlParser.unescape(numStr);
decoded_num = XmlParser.unescape(decoded_num);
decoded_num = Base64.decodeToHex(decoded_num);
NUM_TYPE num_type = new NUM_TYPE(decoded_num);
PIC pic = new PIC(picStr, attr, 0);
return(num_type.toDisplayValue(pic));
}
public WDT(PIC _pic)
{
this.pic = _pic;
optionRegister = pic.getRegisterFileMap().getAdapter(Register.RegisterConstants.OPTION_REG_BANK1_ADDRESS);
optionRegister.DataChanged += onOptionRegisterChange;
wdtTimer = new System.Timers.Timer();
wdtTimer.Interval = calculateWdtInterval();
wdtTimer.Elapsed += onWdtTimerElapsed;
wdtTimer.AutoReset = false;
}
public static unsafe void Start(uint magic, uint address)
{
/* Setup Multiboot */
Multiboot.Setup(magic, address);
/* Placement Address */
Heap.PlacementAddress = Native.EndOfKernel();
/* Clear Interrupts */
Native.ClearInterrupt();
/* Setup PIC */
PIC.Setup();
/* Setup GDT & Enter into protected mode */
GDT.Setup();
/* Setup IDT */
IDT.Setup();
/* Enable Interrupts */
Native.SetInterrupt();
/* Setup Paging */
Paging.Setup(Multiboot.RAM);
/* Setup Multitasking */
Multitasking.CreateTask(0, true); //This is System Update thread
Multitasking.Init(); //Start Multitasking
/* Call our kernel instance now */
try
{
Caller.Start();
while (true)
{
Caller.Update();
}
}
catch (Exception e)
{
//Kernel PANIC !!
Console.WriteLine(e.Message);
}
while (true) //Set CPU in Infinite loop DON'T REMOVE THIS ELSE I'll KILL YOU (^ . ^)
{
Native.ClearInterrupt();
Native.Halt();
}
;
}
public override byte Calculate(PIC Pic, BytecodeLine Line, byte Value, int BitPosition)
{
if (!Helper.CheckBit(BitPosition, Value))
{
Cycles = 1;
}
else
{
Cycles = 2;
Pic.RegisterMap.ProgrammCounter++; // Nächster Befehl muss übersprungen werden
}
return(Value);
}
private static void Setup()
{
IDT.SetInterruptHandler(null);
Panic.Setup();
Debugger.Setup(Serial.COM1);
// Initialize interrupts
PIC.Setup();
IDT.Setup();
GDT.Setup();
//Runtime.Internal.Setup();
}
private void changeState(PIC.PIC.PicExecutionState newState)
{
picExecutionState = newState;
if (newState == PIC.PIC.PicExecutionState.STOPPED)
{
PlayButton.Image = (System.Drawing.Bitmap)(resources.GetObject("PlayButton.Image"));
}
else
{
PlayButton.Image = (System.Drawing.Bitmap)(resources.GetObject("PauseButton.Image"));
}
}
public InterruptHandler(PIC _pic, Register.RegisterFileMap _registerFileMap)
{
this.pic = _pic;
this.registerFileMap = _registerFileMap;
this.oldPortBValue = registerFileMap.Get(Register.RegisterConstants.PORTB_ADDRESS);
this.oldIntconValue = registerFileMap.Get(Register.RegisterConstants.INTCON_ADDRESS);
this.oldEecon1Value = registerFileMap.Get(Register.RegisterConstants.EECON1_BANK1_ADDRESS);
this.valueChangeListener = new Data.DataAdapter<byte>.OnDataChanged(onValueChange);
this.portBValueChangeListener = new Data.DataAdapter<byte>.OnDataChanged(onPortBValueChange);
registerSelfWithRegisterFileMap();
}
public Timer0Handler(Register.RegisterFileMap _registerFileMap, Timer0.Timer0 _timer0, PIC _pic)
{
pic = _pic;
this.registerFileMap = _registerFileMap;
this.timer0 = _timer0;
lastPortAValue = _registerFileMap.Get(Register.RegisterConstants.PORTA_ADDRESS);
// instance delegates
this.portAValueChangeListener = new Data.DataAdapter<byte>.OnDataChanged(onPortAValueChange);
this.tmr0RegisterChangeListener = new Data.DataAdapter<byte>.OnDataChanged(onTMR0RegisterChanged);
this.cycleEndListener = new PIC.OnCycleEnd(onCycleEnd);
registerDelegates();
}
public override byte Calculate(PIC Pic, Data.BytecodeLine Line, byte Value)
{
int WComp = ~Pic.WRegister.Value;
WComp += 0x1;
int NewValue = Value + WComp;
Pic.RegisterMap.CarryBit = NewValue >= 0;
NewValue = (byte)NewValue;
Pic.RegisterMap.DigitalCarryBit = (Value & 0xF) + (WComp & 0xF) > 0xF;
return((byte)NewValue);
}
public ListingForm(string _pathToFile, PIC.PIC _pic)
{
InitializeComponent();
programView = new GUI.ProgramView(_pathToFile);
foreach(string item in programView.source) {
dataGridView1.Rows.Add(item);
}
_pic.nextInstructionEvent += onNextInstructionExecution;
Disposed += delegate { _pic.nextInstructionEvent -= onNextInstructionExecution; };
programMemory = _pic.getProgramMemory();
numberOfLinesDisplayed = dataGridView1.Height / dataGridView1.RowTemplate.Height;
}
public SpecialValueForm(PIC.PIC _pic)
{
InitializeComponent();
pic = _pic;
stackBoxes = new TextBox[PIC.Data.OperationStack.STACK_SIZE];
pic.getOperationStack().registerStackUpdateListener(onStackUpdate);
pic.registerExecutedCyclesListener(onExecutedCyclesUpdate);
Disposed += delegate {
pic.getOperationStack().unregisterStackUpdateListener(onStackUpdate);
pic.unregisterExecutedCyclesListener(onExecutedCyclesUpdate);
};
createValueDisplays();
Paint += drawVerticalLine;
}
public PulseGeneratorForm(PIC.PIC pic)
{
InitializeComponent();
portAAdapter = (PIC.Ports.IOAdapter) pic.getRegisterFileMap().getAdapter(PIC.Register.RegisterConstants.PORTA_ADDRESS);
portBAdapter = (PIC.Ports.IOAdapter) pic.getRegisterFileMap().getAdapter(PIC.Register.RegisterConstants.PORTB_ADDRESS);
intervalABox.Text = DEFAULT_INTERVAL.ToString();
intervalBBox.Text = DEFAULT_INTERVAL.ToString();
portATimer.Elapsed += portATimer_Elapsed;
portBTimer.Elapsed += portBTimer_Elapsed;
int i = 0;
Label label;
// PORT-Checkboxes dynamisch erstellen
for (i = 0; i < 8; i++)
{
portACheckBoxes[7-i] = new CheckBox();
portACheckBoxes[7-i].SetBounds(CHECKBOX_X_OFFSET + i * (CHECKBOX_WIDTH + CHECKBOX_SPACING), CHECKBOX_PORTA_Y_OFFSET, CHECKBOX_WIDTH, CHECKBOX_WIDTH);
portACheckBoxes[7-i].Parent = this;
portACheckBoxes[7-i].MouseClick += new MouseEventHandler(portACheckboxChanged);
label = new Label();
label.Text = (7 - i).ToString();
label.SetBounds(CHECKBOX_X_OFFSET + i * (CHECKBOX_WIDTH + CHECKBOX_SPACING), LABEL_PORTA_Y_OFFSET, CHECKBOX_WIDTH, CHECKBOX_WIDTH);
label.Parent = this;
label.Show();
label.BringToFront();
portBCheckBoxes[7-i] = new CheckBox();
portBCheckBoxes[7-i].SetBounds(CHECKBOX_X_OFFSET + i * (CHECKBOX_WIDTH + CHECKBOX_SPACING), CHECKBOX_PORTB_Y_OFFSET, CHECKBOX_WIDTH, CHECKBOX_WIDTH);
portBCheckBoxes[7-i].Parent = this;
portBCheckBoxes[7-i].MouseClick += new MouseEventHandler(portBCheckboxChanged);
label = new Label();
label.Text = (7 - i).ToString();
label.SetBounds(CHECKBOX_X_OFFSET + i * (CHECKBOX_WIDTH + CHECKBOX_SPACING), LABEL_PORTB_Y_OFFSET, CHECKBOX_WIDTH, CHECKBOX_WIDTH);
label.Parent = this;
label.Show();
label.BringToFront();
}
}
private void setSelectedBits(PIC.Ports.IOAdapter portAdapter, byte portBitmask)
{
portAdapter.Input = (byte)(portAdapter.Value | portBitmask);
}
/// <summary>
/// Creates a new SleepOperation
/// </summary>
/// <param name="_pic">needed to put into sleep</param>
/// <param name="_registerFileMap"></param>
/// <param name="_address">code address</param>
public SleepOperation(PIC _pic, Register.RegisterFileMap _registerFileMap, short _address)
: base(_registerFileMap, CYCLES, _address)
{
pic = _pic;
}
/// <summary>
/// Starts the ISA devices.
/// </summary>
public static void StartISADevices()
{
//LinkedList<DeviceDriver> deviceDrivers = deviceDriverRegistry.GetISADeviceDrivers();
//foreach (DeviceDriver deviceDriver in deviceDrivers)
// StartDevice(deviceDriver);
//[ISADeviceDriver(AutoLoad = true, BasePort = 0x60, PortRange = 1, AltBasePort = 0x64, AltPortRange = 1, IRQ = 1, Platforms = PlatformArchitecture.X86AndX64)]
ISADeviceDriverAttribute keyboardDeviceAttributes = new ISADeviceDriverAttribute();
keyboardDeviceAttributes.AutoLoad = true;
keyboardDeviceAttributes.BasePort = 0x60;
keyboardDeviceAttributes.PortRange = 1;
keyboardDeviceAttributes.AltBasePort = 0x64;
keyboardDeviceAttributes.IRQ = 1;
keyboardDeviceAttributes.Platforms = PlatformArchitecture.X86AndX64;
//[ISADeviceDriver(AutoLoad = true, BasePort = 0x0CF8, PortRange = 8, Platforms = PlatformArchitecture.X86AndX64)]
ISADeviceDriverAttribute pciAttributes = new ISADeviceDriverAttribute();
pciAttributes.AutoLoad = true;
pciAttributes.BasePort = 0x0CF8;
pciAttributes.PortRange = 8;
pciAttributes.Platforms = PlatformArchitecture.X86AndX64;
//[ISADeviceDriver(AutoLoad = true, BasePort = 0x20, PortRange = 2, AltBasePort = 0xA0, AltPortRange = 2, Platforms = PlatformArchitecture.X86AndX64)]
ISADeviceDriverAttribute picAttributes = new ISADeviceDriverAttribute();
picAttributes.AutoLoad = true;
picAttributes.BasePort = 0x20;
picAttributes.PortRange = 2;
picAttributes.AltBasePort = 0xA0;
picAttributes.AltPortRange = 2;
picAttributes.Platforms = PlatformArchitecture.X86AndX64;
//[ISADeviceDriver(AutoLoad = true, BasePort = 0x40, PortRange = 4, IRQ = 0, Platforms = PlatformArchitecture.X86AndX64)]
ISADeviceDriverAttribute pitAttributes = new ISADeviceDriverAttribute();
pitAttributes.AutoLoad = true;
pitAttributes.BasePort = 0x40;
pitAttributes.PortRange = 4;
pitAttributes.IRQ = 0;
pitAttributes.Platforms = PlatformArchitecture.X86AndX64;
Keyboard = new StandardKeyboard();
PCI = new PCIController();
PIC = new PIC();
PIT = new PIT();
//StartDevice(picAttributes, PIC);
StartDevice(pitAttributes, PIT);
StartDevice(pciAttributes, PCI);
StartDevice(keyboardDeviceAttributes, Keyboard);
PCIControllerManager pciController = new PCIControllerManager(deviceManager);
Console.Write("Probing PCI devices...");
//pciController.CreatePCIDevices();
Console.WriteLine("[Completed]");
}
private void onPicExecutionChange(PIC.PIC.PicExecutionState value, object sender)
{
MethodInvoker mi = delegate { changeState(value); };
if (InvokeRequired)
{
try
{
this.BeginInvoke(mi); // Async to prohibit deadlock
}
catch (ObjectDisposedException)
{
// ignore, the listener is not yet unregistered...
}
}
else
{
changeState(value);
}
}
public ByteRegister this[PIC r]
{
get { return this[(uint)r]; }
set { this[(uint)r] = value; }
}
private Vector3 P(PIC p)
{
var firstHalfOfCircle = Mathf.Sin(_fillingHeight * Mathf.PI) / 3;
switch (p)
{
/* Up 4 corners*/
case PIC.UFR: return new Vector3(1 - firstHalfOfCircle, FillingHeight+1, 1 - firstHalfOfCircle);
case PIC.UFL: return new Vector3(0 + firstHalfOfCircle, FillingHeight+1, 1 - firstHalfOfCircle);
case PIC.UBL: return new Vector3(0 + firstHalfOfCircle, FillingHeight+1, 0 + firstHalfOfCircle);
case PIC.UBR: return new Vector3(1 - firstHalfOfCircle, FillingHeight+1, 0 + firstHalfOfCircle);
/* Down 4 Corners*/
case PIC.DFR: return new Vector3(1, 0, 1);
case PIC.DFL: return new Vector3(0, 0, 1);
case PIC.DBL: return new Vector3(0, 0, 0);
case PIC.DBR: return new Vector3(1, 0, 0);
/* Middles */
case PIC.UM: return new Vector3(0.5f, FillingHeight+1, 0.5f);
case PIC.FM: return new Vector3(0.5f, FillingHeight / 2+1, 1.0f);
case PIC.DM: return new Vector3(0.5f, 0, 0.5f);
case PIC.LM: return new Vector3(0, FillingHeight / 2+1, 0.5f);
case PIC.RM: return new Vector3(1, FillingHeight / 2+1, 0.5f);
case PIC.BM: return new Vector3(0.5f, FillingHeight / 2+1, 0);
default:
throw new ArgumentOutOfRangeException("p");
}
}
private void clearSelectedBits(PIC.Ports.IOAdapter portAdapter, byte portBitmask)
{
portAdapter.Input = (byte)(portAdapter.Value & (~portBitmask));
}
public ClearWdtOperation(PIC _pic, RegisterFileMap _registerFileMap, short _address)
: base(_registerFileMap, CYCLES, _address)
{
this.pic = _pic;
}
