gen: input works in basic form (one 3-button pad)

BizHawk.Emulation/Consoles/Sega/Genesis/IO.cs

@@ -2,16 +2,36 @@
 {
     partial class Genesis
     {
-        public bool SegaCD = false;
+        bool SegaCD = false;
 
-        public byte ReadIO(int offset)
+        class IOPort
         {
-            offset &= 3;
+            public byte Data;
-            byte value;
+            public byte Control;
+            public byte TxData;
+            public byte RxData;
+            public byte SCtrl;
+            // TODO- a reference to connected device? That gets into the issue of configuring different types of controllers. :|
+
+            public bool TH { get { return (Data & 0x40) != 0; } }
+        }
+
+        IOPort[] IOPorts = new IOPort[] 
+        { 
+            new IOPort { Data = 0x7F, TxData = 0xFF, RxData = 0xFF, SCtrl = 0xFF }, 
+            new IOPort { Data = 0x7F, TxData = 0xFF, RxData = 0xFF, SCtrl = 0xFF }, 
+            new IOPort { Data = 0x7F, TxData = 0xFF, RxData = 0xFF, SCtrl = 0xFF } 
+        };
+
+        byte ReadIO(int offset)
+        {
+            offset >>= 1;
+            offset &= 0x0F;
+
             switch (offset)
             {
                 case 0: // version
-                    value = (byte) (SegaCD ? 0x00 : 0x20);
+                    byte value = (byte) (SegaCD ? 0x00 : 0x20);
                     switch((char)RomData[0x01F0])
                     {
                         case 'J': value |= 0x00; break;
@@ -22,13 +42,86 @@
                         default:  value |= 0x80; break;
                     }
                     //value |= 1; // US
+                    Log.Note("CPU", "^^^ IO Read 0: {0:X2}", value);
                     return value;
+                case 1: // Port A 
+                    ReadController(ref IOPorts[0].Data);
+                    Log.Note("CPU", "^^^ IO Read 1: {0:X2}", IOPorts[0].Data);
+                    return IOPorts[0].Data;
+                case 2: return 0xFF;
+                case 3: return 0xFF;
+
+                case 0x04: return IOPorts[0].Control;
+                case 0x05: return IOPorts[1].Control;
+                case 0x06: return IOPorts[2].Control;
+
+                case 0x07: return IOPorts[0].TxData;
+                case 0x08: return IOPorts[0].RxData;
+                case 0x09: return IOPorts[0].SCtrl;
+
+                case 0x0A: return IOPorts[1].TxData;
+                case 0x0B: return IOPorts[1].RxData;
+                case 0x0C: return IOPorts[1].SCtrl;
+
+                case 0x0D: return IOPorts[2].TxData;
+                case 0x0E: return IOPorts[2].RxData;
+                case 0x0F: return IOPorts[2].SCtrl;
             }
+            Log.Note("CPU", "^^^ IO Read {0}: {1:X2}", offset, 0xFF);
             return 0xFF;
         }
 
-        public void WriteIO(int offset, int value)
+        void WriteIO(int offset, int value)
         {
+            offset >>= 1;
+            offset &= 0x0F;
+
+            switch (offset)
+            {
+                case 0x00: break;
+
+                case 0x01: IOPorts[0].Data = (byte) value; break;
+                case 0x02: IOPorts[1].Data = (byte) value; break;
+                case 0x03: IOPorts[2].Data = (byte) value; break;
+
+                case 0x04: IOPorts[0].Control = (byte) value; break;
+                case 0x05: IOPorts[1].Control = (byte) value; break;
+                case 0x06: IOPorts[2].Control = (byte) value; break;
+
+                case 0x07: IOPorts[0].TxData = (byte) value; break;
+                case 0x08: IOPorts[0].RxData = (byte) value; break;
+                case 0x09: IOPorts[0].SCtrl  = (byte) value; break;
+
+                case 0x0A: IOPorts[1].TxData = (byte) value; break;
+                case 0x0B: IOPorts[1].RxData = (byte) value; break;
+                case 0x0C: IOPorts[1].SCtrl  = (byte) value; break;
+
+                case 0x0D: IOPorts[2].TxData = (byte) value; break;
+                case 0x0E: IOPorts[2].RxData = (byte) value; break;
+                case 0x0F: IOPorts[2].SCtrl  = (byte) value; break;
+            }
+        }
+
+        void ReadController(ref byte data)
+        {
+            System.Console.WriteLine("START => " + Controller["P1 Start"]);
+            data &= 0xC0;
+            if ((data & 0x40) != 0) // TH high
+            {
+                if (Controller["P1 Up"]    == false) data |= 0x01;
+                if (Controller["P1 Down"]  == false) data |= 0x02;
+                if (Controller["P1 Left"]  == false) data |= 0x04;
+                if (Controller["P1 Right"] == false) data |= 0x08;
+                if (Controller["P1 B"]     == false) data |= 0x10;
+                if (Controller["P1 C"]     == false) data |= 0x20;
+                System.Console.WriteLine("TH HIGH: {0:X}",data);
+            } else { // TH low
+                if (Controller["P1 Up"] == false) data |= 0x01;
+                if (Controller["P1 Down"] == false) data |= 0x02;
+                if (Controller["P1 A"] == false) data |= 0x10;
+                if (Controller["P1 Start"] == false) data |= 0x20;
+                System.Console.WriteLine("TH LOW: {0:X}", data);
+            }
             
         }
     }

BizHawk.Emulation/Consoles/Sega/Genesis/Input.cs

@@ -6,23 +6,12 @@
         {
             Name = "Genesis 3-Button Controller",
             BoolButtons =
-                        {
+                {
-                            "Reset",
+                    "Reset",
-                            "P1 Up", "P1 Down", "P1 Left", "P1 Right", "P1 A", "P1 B", "P1 C", "P1 Start"
+                    "P1 Up", "P1 Down", "P1 Left", "P1 Right", "P1 A", "P1 B", "P1 C", "P1 Start"
-                        }
+                }
         };
 
-
-        public string GetControllersAsMnemonic()
-        {
-            return "|........|0|"; //TODO: implement
-        }
-
-        public void SetControllersAsMnemonic(string mnemonic)
-        {
-            //TODO
-        }
-
         public ControllerDefinition ControllerDefinition { get { return GenesisController; } }
         public IController Controller { get; set; }
     }

BizHawk.Emulation/Consoles/Sega/Genesis/MemoryMap.68000.cs

@@ -10,8 +10,6 @@ namespace BizHawk.Emulation.Consoles.Sega
 
             if (address < 0x400000)
                 return (sbyte) RomData[address];
-            if (address >= 0xA10000 && address < 0xA1001F)
-                return (sbyte) ReadIO((address >> 1) & 0x0F);
 
             if (address >= 0xE00000)
                 return (sbyte) Ram[address & 0xFFFF];
@@ -22,10 +20,11 @@ namespace BizHawk.Emulation.Consoles.Sega
                 return (sbyte) (M68000HasZ80Bus && Z80Reset == false ? 0 : 1);
             }
 
+            if (address >= 0xA10000 && address <= 0xA1001F)
+                return (sbyte)ReadIO(address);
+
             if ((address & 0xFF0000) == 0xA00000)
-            {
                 return (sbyte) ReadMemoryZ80((ushort) (address & 0x7FFF));
-            }
 
             if (address >= 0xC00004 && address < 0xC00008)
             {
@@ -56,7 +55,8 @@ namespace BizHawk.Emulation.Consoles.Sega
             if (address >= 0xC00004 && address < 0xC00008)
                 return (short) VDP.ReadVdpControl();
 
-            if (address == 0xA1000C) return 0; // FIXME HACK for tg-sync.
+            if (address >= 0xA10000 && address <= 0xA1001F)
+                return (sbyte)ReadIO(address);
 
             Console.WriteLine("UNHANDLED READW {0:X6}", address);
             return 0x7DCD;
@@ -97,6 +97,11 @@ namespace BizHawk.Emulation.Consoles.Sega
                 WriteMemoryZ80((ushort)(address & 0x7FFF), (byte)value);
                 return;
             }
+            if (address >= 0xA10000 && address <= 0xA1001F)
+            {
+                WriteIO(address, value); 
+                return;
+            }
             if (address == 0xA11100)
             {
                 M68000HasZ80Bus = (value & 1) != 0;