romdev-mcp 0.1.1

package/src/platforms/genesis/lib/sgdk/src/joy.c

@@ -0,0 +1,1361 @@
+#include "config.h"
+#include "types.h"
+
+#include "timer.h"
+#include "memory.h"
+
+#include "joy.h"
+#include "sys.h"
+#include "vdp.h"
+#include "tools.h"
+#include "z80_ctrl.h"
+
+
+#define JOY_TYPE_SHIFT          12
+
+#if (HALT_Z80_ON_IO != 0)
+    #define Z80_STATE_DECL      u16 z80state;
+    #define Z80_STATE_SAVE      z80state = Z80_getAndRequestBus(TRUE);
+    #define Z80_STATE_RESTORE   if (!z80state) Z80_releaseBus();
+#else
+    #define Z80_STATE_DECL
+    #define Z80_STATE_SAVE
+    #define Z80_STATE_RESTORE
+#endif
+
+
+
+// don't want to share it
+extern bool randomSeedSet;
+
+static vu8 joyType[8];
+static vu16 joyState[8];
+static vs16 joyAxisX[8];
+static vs16 joyAxisY[8];
+
+static u8 portSupport[2];
+static u8 portType[2];
+
+static u8 retry;
+static u8 phase;
+
+static u8 gun;
+static u8 extSet;
+static u16 gport;
+
+
+static JoyEventCallback *joyEventCB;
+
+
+void JOY_init()
+{
+    /* Reset controller state change event callback */
+    joyEventCB = NULL;
+    /* Then perform controller port reset and peripheral detection */
+    JOY_reset();
+}
+
+NO_INLINE void JOY_reset()
+{
+    vu8 *pb;
+    u8 a, b;
+    u8 id;
+    u16 i;
+    Z80_STATE_DECL
+
+    gport = 0xFFFF;
+
+    /* disable ints (we can do it here for safety) */
+    SYS_disableInts();
+
+    Z80_STATE_SAVE
+
+    /* check for EA 4-Way Play */
+    pb = (vu8 *)0xa10009;
+    *pb = 0x40;
+    pb = (vu8 *)0xa1000b;
+    *pb = 0x7F;
+    pb = (vu8 *)0xa10003;
+    *pb = 0x40;
+
+    pb = (vu8 *)0xa10005;
+    *pb = 0x0C;
+    asm volatile ("nop");
+    asm volatile ("nop");
+    pb = (vu8 *)0xa10003;
+    a = *pb & 3;
+
+    pb = (vu8 *)0xa10005;
+    *pb = 0x7C;
+    asm volatile ("nop");
+    asm volatile ("nop");
+    pb = (vu8 *)0xa10003;
+    b = *pb & 3;
+
+    Z80_STATE_RESTORE
+
+    /* EA 4-Way Play detected */
+    if (a != 0 && b == 0)
+    {
+        /* EA 4-Way Play is the only thing that can be plugged in as it takes both ports */
+        portType[PORT_1] = PORT_TYPE_EA4WAYPLAY;
+        portType[PORT_2] = PORT_TYPE_EA4WAYPLAY;
+        portSupport[PORT_1] = JOY_SUPPORT_EA4WAYPLAY;
+        portSupport[PORT_2] = JOY_SUPPORT_OFF;
+
+        for (i=JOY_1; i<JOY_NUM; i++)
+        {
+            joyType[i] = JOY_TYPE_UNKNOWN; /* default to unknown */
+            joyState[i] = 0;
+            joyAxisX[i] = 0;
+            joyAxisY[i] = 0;
+        }
+    }
+    else
+    {
+        /*
+         * Initialize ports for peripheral interface protocol - default to
+         * TH Control Method for pads
+         */
+
+        Z80_STATE_SAVE
+
+        /* set the port bits direction */
+        pb = (vu8 *)0xa10009;
+        *pb = 0x40;
+        pb += 2;
+        *pb = 0x40;
+        pb += 2;
+        *pb = 0x40;
+        /* set the port bits value */
+        pb = (vu8 *)0xa10003;
+        *pb = 0x40;
+        pb += 2;
+        *pb = 0x40;
+        pb += 2;
+        *pb = 0x40;
+
+        Z80_STATE_RESTORE
+
+        /* need to wait */
+        VDP_waitVSync();
+        VDP_waitVSync();
+
+        Z80_STATE_SAVE
+
+        /* get ID port 1 */
+        pb = (vu8 *)0xa10003;
+        a = *pb;
+        *pb = 0x00;
+        id = (a & 8) | (a & 4) ? 8 : 0;
+        id |= (a & 2) | (a & 1) ? 4 : 0;
+        a = *pb;
+        *pb = 0x40;
+        id |= (a & 8) | (a & 4) ? 2 : 0;
+        id |= (a & 2) | (a & 1) ? 1 : 0;
+        portType[PORT_1] = id;
+
+        /* get ID port 2 */
+        pb = (vu8 *)0xa10005;
+        a = *pb;
+        *pb = 0x00;
+        id = (a & 8) | (a & 4) ? 8 : 0;
+        id |= (a & 2) | (a & 1) ? 4 : 0;
+        a = *pb;
+        *pb = 0x40;
+        id |= (a & 8) | (a & 4) ? 2 : 0;
+        id |= (a & 2) | (a & 1) ? 1 : 0;
+        portType[PORT_2] = id;
+
+        Z80_STATE_RESTORE
+
+        /* now set the port support */
+        portSupport[PORT_1] = JOY_SUPPORT_OFF; /* default to off */
+        portSupport[PORT_2] = JOY_SUPPORT_OFF; /* default to off */
+
+        for (i=JOY_1; i<JOY_NUM; i++)
+        {
+            joyType[i] = JOY_TYPE_UNKNOWN; /* default to unknown */
+            joyState[i] = 0;
+            joyAxisX[i] = 0;
+            joyAxisY[i] = 0;
+        }
+
+        Z80_STATE_SAVE
+
+        switch (portType[PORT_1])
+        {
+            case PORT_TYPE_MENACER:
+            case PORT_TYPE_JUSTIFIER:
+                /* init port for light gun control */
+                pb = (vu8 *)0xa10009;
+                *pb = 0x30;
+                pb = (vu8 *)0xa10003;
+                *pb = 0x30;
+                break;
+
+            case PORT_TYPE_MOUSE:
+            case PORT_TYPE_TEAMPLAYER:
+                /* init port for Three Line Handshake Method */
+                pb = (vu8 *)0xa10009;
+                *pb = 0x60;
+                pb = (vu8 *)0xa10003;
+                *pb = 0x60;
+                break;
+
+            case PORT_TYPE_PAD:
+                portSupport[PORT_1] = JOY_SUPPORT_6BTN; /* default to on for pads */
+                break;
+        }
+
+        switch (portType[PORT_2])
+        {
+            case PORT_TYPE_MENACER:
+            case PORT_TYPE_JUSTIFIER:
+                /* init port for light gun control */
+                pb = (vu8 *)0xa1000b;
+                *pb = 0x30;
+                pb = (vu8 *)0xa10005;
+                *pb = 0x30;
+                break;
+
+            case PORT_TYPE_MOUSE:
+            case PORT_TYPE_TEAMPLAYER:
+                /* init port for Three Line Handshake Method */
+                pb = (vu8 *)0xa1000b;
+                *pb = 0x60;
+                pb = (vu8 *)0xa10005;
+                *pb = 0x60;
+                break;
+
+            case PORT_TYPE_PAD:
+                portSupport[PORT_2] = JOY_SUPPORT_6BTN; /* default to on for pads */
+                break;
+        }
+
+        Z80_STATE_RESTORE
+
+        /* check if need to turn on an input device */
+        if ((portType[PORT_1] != PORT_TYPE_PAD) && (portType[PORT_2] != PORT_TYPE_PAD))
+        {
+            /* no pads - look for teamplayer or mouse */
+            if (portType[PORT_1] == PORT_TYPE_TEAMPLAYER)
+                JOY_setSupport(PORT_1, JOY_SUPPORT_TEAMPLAYER);
+            else if (portType[PORT_2] == PORT_TYPE_TEAMPLAYER)
+                JOY_setSupport(PORT_2, JOY_SUPPORT_TEAMPLAYER);
+            else if (portType[PORT_1] == PORT_TYPE_MOUSE)
+                JOY_setSupport(PORT_1, JOY_SUPPORT_MOUSE);
+            else if (portType[PORT_2] == PORT_TYPE_MOUSE)
+                JOY_setSupport(PORT_2, JOY_SUPPORT_MOUSE);
+        }
+    }
+
+    /* now update pads to reflect true type (3 or 6 button) */
+    if ((portType[PORT_1] == PORT_TYPE_PAD) && (joyType[JOY_1] == JOY_TYPE_PAD3))
+        portSupport[PORT_1] = JOY_SUPPORT_3BTN;
+    if ((portType[PORT_2] == PORT_TYPE_PAD) && (joyType[JOY_2] == JOY_TYPE_PAD3))
+        portSupport[PORT_2] = JOY_SUPPORT_3BTN;
+
+    /* restore ints */
+    SYS_enableInts();
+
+    /* wait a few vblanks for JOY_update() to get valid data */
+    SYS_doVBlankProcess();
+    SYS_doVBlankProcess();
+    SYS_doVBlankProcess();
+}
+
+
+JoyEventCallback* JOY_getEventHandler()
+{
+    return joyEventCB;
+}
+
+void JOY_setEventHandler(JoyEventCallback *CB)
+{
+    joyEventCB = CB;
+}
+
+
+static void externalIntCB()
+{
+    vu8 *pb;
+    u16 hv;
+    Z80_STATE_DECL
+
+    hv = GET_HVCOUNTER;                     /* read HV counter */
+
+    if (extSet || (gport == 0xFFFF)) return;
+
+    Z80_STATE_SAVE
+
+    pb = (vu8 *)0xa10003 + (gport * 2);
+    if (portType[gport] == PORT_TYPE_JUSTIFIER)
+        *pb = gun | 0x10;                   /* deselect gun */
+
+    Z80_STATE_RESTORE
+
+    if (!gun)
+    {
+        /* blue gun or menacer or phaser */
+        joyAxisX[gport] = hv & 0x00FF;
+        joyAxisY[gport] = hv >> 8;
+    }
+    else
+    {
+        /* red gun */
+        joyAxisX[gport ? JOY_6 : JOY_3] = hv & 0x00FF;
+        joyAxisY[gport ? JOY_6 : JOY_3] = hv >> 8;
+    }
+
+    extSet = 1;                             /* we got light sense */
+}
+
+
+NO_INLINE void JOY_setSupport(u16 port, u16 support)
+{
+    Z80_STATE_DECL
+
+    if (port > PORT_2) return;
+
+    if ((portType[port] == PORT_TYPE_MENACER) || (portType[port] == PORT_TYPE_JUSTIFIER))
+    {
+        vu8 *pb;
+        u8 val;
+
+        if ((support == JOY_SUPPORT_JUSTIFIER_BLUE) || (support == JOY_SUPPORT_JUSTIFIER_BOTH) || (support == JOY_SUPPORT_MENACER))
+        {
+            /* enable lightgun support if support currently off */
+            if (portSupport[port] == JOY_SUPPORT_OFF)
+            {
+                SYS_setInterruptMaskLevel(7);   /* disable ints */
+
+                /* OBVIOUSLY blue gun or menacer is present due to portType ID */
+                joyType[port] = (support == JOY_SUPPORT_MENACER) ? JOY_TYPE_MENACER : JOY_TYPE_JUSTIFIER;
+                joyState[port] = 0;
+                joyAxisX[port] = -1;
+                joyAxisY[port] = -1;
+
+                gun = 0;
+                extSet = 0;
+                gport = port;
+                if (support == JOY_SUPPORT_JUSTIFIER_BOTH)
+                {
+                    joyType[port ? JOY_6 : JOY_3] = JOY_TYPE_JUSTIFIER; /* allow red gun */
+                    joyState[port ? JOY_6 : JOY_3] = 0;
+                    joyAxisX[port ? JOY_6 : JOY_3] = -1;
+                    joyAxisY[port ? JOY_6 : JOY_3] = -1;
+                }
+
+                SYS_setExtIntCallback(externalIntCB);
+
+                Z80_STATE_SAVE
+
+                pb = (vu8 *)0xa10009 + port*2;
+                *pb = 0xB0;                     /* enable TH->HL */
+
+                Z80_STATE_RESTORE
+
+                VDP_setHVLatching(TRUE);        /* enable HV counter latch */
+                val = VDP_getReg(11);
+                VDP_setReg(11, val | 0x08);     /* set IE2, enable external int */
+
+                SYS_setInterruptMaskLevel(1);   /* External int allowed */
+
+                /* set last since this starts the vblank handling of the gun(s) */
+                portSupport[port] = support;
+            }
+        }
+        else if (support == JOY_SUPPORT_OFF)
+        {
+            /* disable lightgun support if was on */
+            if ((portSupport[port] == JOY_SUPPORT_JUSTIFIER_BLUE) || (portSupport[port] == JOY_SUPPORT_JUSTIFIER_BOTH) || (portSupport[port] == JOY_SUPPORT_MENACER))
+            {
+                SYS_setInterruptMaskLevel(7);       /* disable ints */
+
+                Z80_STATE_SAVE
+
+                pb = (vu8 *)0xa10009 + port*2;
+                *pb = 0x30;                         /* disable TH->HL */
+
+                Z80_STATE_RESTORE
+
+                VDP_setHVLatching(FALSE);           /* disable HV counter latch */
+                val = VDP_getReg(11);
+                VDP_setReg(11, val & ~0x08);        /* clear IE2, disable external int */
+
+                SYS_setExtIntCallback(NULL);
+
+                if (port == PORT_1)
+                {
+                    joyType[JOY_1] = JOY_TYPE_UNKNOWN;
+                    joyType[JOY_3] = JOY_TYPE_UNKNOWN;
+                    joyState[JOY_1] = 0;
+                    joyState[JOY_3] = 0;
+                }
+                else
+                {
+                    joyType[JOY_2] = JOY_TYPE_UNKNOWN;
+                    joyType[JOY_6] = JOY_TYPE_UNKNOWN;
+                    joyState[JOY_2] = 0;
+                    joyState[JOY_6] = 0;
+                }
+
+                gport = 0xFFFF;
+
+                SYS_setInterruptMaskLevel(3);       /* External int disallowed */
+            }
+
+            portSupport[port] = JOY_SUPPORT_OFF;
+        }
+        else if (support == JOY_SUPPORT_TRACKBALL)
+        {
+            /*
+             * The port ID for the trackball is 0x0F the first time, then
+             * 0x00 (same as menacer) until you power off.
+             *
+             * Reset port direction and data for TH Control Method.
+             */
+            Z80_STATE_SAVE
+
+            pb = (vu8 *)0xa10009 + port*2;
+            *pb = 0x40;
+            pb = (vu8 *)0xa10003 + port*2;
+            *pb = 0x40;
+
+            Z80_STATE_RESTORE
+
+            portSupport[port] = support;
+        }
+    }
+    else if ((support == JOY_SUPPORT_PHASER) || (support == JOY_SUPPORT_OFF))
+    {
+        vu8 *pb;
+        u8 val;
+
+        if (support == JOY_SUPPORT_PHASER)
+        {
+            /* enable lightgun support if support currently off */
+            if (portSupport[port] == JOY_SUPPORT_OFF)
+            {
+                SYS_setInterruptMaskLevel(7);   /* disable ints */
+
+                joyType[port] = JOY_TYPE_PHASER;
+                joyState[port] = 0;
+                joyAxisX[port] = -1;
+                joyAxisY[port] = -1;
+
+                gun = 0;
+                extSet = 0;
+                gport = port;
+
+                SYS_setExtIntCallback(externalIntCB);
+
+                Z80_STATE_SAVE
+
+                pb = (vu8 *)0xa10009 + port*2;
+                *pb = 0x80;                     /* enable TH->HL */
+
+                Z80_STATE_RESTORE
+
+                VDP_setHVLatching(TRUE);        /* enable HV counter latch */
+                val = VDP_getReg(11);
+                VDP_setReg(11, val | 0x08);     /* set IE2, enable external int */
+
+                SYS_setInterruptMaskLevel(1);   /* External int allowed */
+
+                /* set last since this starts the vblank handling of the gun(s) */
+                portSupport[port] = support;
+            }
+        }
+        else if (support == JOY_SUPPORT_OFF)
+        {
+            /* disable lightgun support if was on */
+            if (portSupport[port] == JOY_SUPPORT_PHASER)
+            {
+                SYS_setInterruptMaskLevel(7);       /* disable ints */
+
+                Z80_STATE_SAVE
+
+                pb = (vu8 *)0xa10009 + port*2;
+                *pb = 0x40;                         /* disable TH->HL */
+
+                Z80_STATE_RESTORE
+
+                VDP_setHVLatching(FALSE);           /* disable HV counter latch */
+                val = VDP_getReg(11);
+                VDP_setReg(11, val & ~0x08);        /* clear IE2, disable external int */
+
+                SYS_setExtIntCallback(NULL);
+
+                if (port == PORT_1)
+                {
+                    joyType[JOY_1] = JOY_TYPE_UNKNOWN;
+                    joyState[JOY_1] = 0;
+                }
+                else
+                {
+                    joyType[JOY_2] = JOY_TYPE_UNKNOWN;
+                    joyState[JOY_2] = 0;
+                }
+
+                gport = 0xFFFF;
+
+                SYS_setInterruptMaskLevel(3);       /* External int disallowed */
+            }
+
+            portSupport[port] = JOY_SUPPORT_OFF;
+        }
+    }
+    else portSupport[port] = support;
+}
+
+
+u8 JOY_getPortType(u16 port)
+{
+    if (port > PORT_2) return PORT_TYPE_UNKNOWN;
+
+    return portType[port];
+}
+
+u8 JOY_getJoypadType(u16 joy)
+{
+    if (joy < JOY_NUM)
+        return joyType[joy];
+
+    return JOY_TYPE_UNKNOWN;
+}
+
+u16 JOY_readJoypad(u16 joy)
+{
+    if (joy == JOY_ALL)
+    {
+        u16 i;
+        u16 res;
+
+        res = 0;
+        i = JOY_NUM;
+        while(i--) res |= joyState[i] &  BUTTON_ALL;
+
+        return res;
+    }
+    else if (joy < JOY_NUM) return joyState[joy];
+
+    return 0;
+}
+
+
+s16 JOY_readJoypadX(u16 joy)
+{
+    if (joy < JOY_NUM) return joyAxisX[joy];
+
+    return 0;
+}
+
+s16 JOY_writeJoypadX(u16 joy, u16 pos)
+{
+    if (joy < JOY_NUM) joyAxisX[joy]=pos;
+
+    return 0;
+}
+
+s16 JOY_readJoypadY(u16 joy)
+{
+    if (joy < JOY_NUM) return joyAxisY[joy];
+
+    return 0;
+}
+
+s16 JOY_writeJoypadY(u16 joy, u16 pos)
+{
+    if (joy < JOY_NUM) joyAxisY[joy] = pos;
+
+    return 0;
+}
+
+
+void JOY_waitPressBtn()
+{
+    JOY_waitPressTime(JOY_ALL, BUTTON_BTN, 0);
+}
+
+u16 JOY_waitPressBtnTime(u16 time)
+{
+    return JOY_waitPressTime(JOY_ALL, BUTTON_BTN, time);
+}
+
+u16 JOY_waitPress(u16 joy, u16 btn)
+{
+    return JOY_waitPressTime(joy, btn, 0);
+}
+
+u16 JOY_waitPressTime(u16 joy, u16 btn, u16 time)
+{
+    u32 maxtime;
+    u32 current;
+
+    // (getTime() << 2) give a good estimation of time in ms
+    current = (getTime(TRUE) << 2);
+
+    // time == 0 --> wait indefinitely
+    if (time) maxtime = current + time;
+    else maxtime = 0xFFFFFFFF;
+
+    while(current < maxtime)
+    {
+        u16 state;
+
+        // more than 1 frame remaining ? directly use SYS_doVBlankProcess()
+        if ((maxtime - current) >= 20) SYS_doVBlankProcess();
+        // just update JOY states
+        else JOY_update();
+
+        if (joy == JOY_ALL)
+        {
+            u16 i;
+
+            i = JOY_NUM;
+            while(i--)
+            {
+                state = joyState[i] & btn;
+                if (state) return state;
+            }
+        }
+        else
+        {
+            state = joyState[joy] & btn;
+            if (state) return state;
+        }
+
+        // (getTime() << 2) give a good estimation of time in ms
+        current = (getTime(TRUE) << 2);
+    }
+
+    return FALSE;
+}
+
+
+static u16 TH_CONTROL_PHASE(vu8 *pb)
+{
+    u16 val;
+
+    *pb = 0x00; /* TH (select) low */
+    asm volatile ("nop");
+    asm volatile ("nop");
+    val = *pb;
+
+    *pb = 0x40; /* TH (select) high */
+    val <<= 8;
+    val |= *pb;
+
+    return val;
+}
+
+static u8 THREELINE_HANDSHAKE(vu8 *pb, u8 ph)
+{
+    u8 val = 0, hs;
+
+    *pb = ph; /* next phase in protocol */
+
+    /* wait on handshake */
+    hs = (ph >> 1) & 0x10;
+    while (retry)
+    {
+        val = *pb;
+        if ((val & 0x10) == hs)
+            break; /* timeout */
+        retry--;
+    }
+
+    return val & 0x0F;
+}
+
+
+static u16 read3Btn(u16 port)
+{
+    vu8 *pb;
+    u16 val;
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+
+    Z80_STATE_SAVE
+    val = TH_CONTROL_PHASE(pb);                   /* - 0 s a 0 0 d u - 1 c b r l d u */
+    Z80_STATE_RESTORE
+
+    val = ((val & 0x3000) >> 6) | (val & 0x003F); /* 0 0 0 0 0 0 0 0 s a c b r l d u */
+    val ^= 0x00FF;                                /* 0 0 0 0 0 0 0 0 S A C B R L D U */
+
+    return val | (JOY_TYPE_PAD3 << JOY_TYPE_SHIFT);
+}
+
+static u16 read6Btn(u16 port)
+{
+    vu8 *pb;
+    u16 val, v1, v2;
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+
+    Z80_STATE_SAVE
+    v1 = TH_CONTROL_PHASE(pb);                    /* - 0 s a 0 0 d u - 1 c b r l d u */
+    val = TH_CONTROL_PHASE(pb);                   /* - 0 s a 0 0 d u - 1 c b r l d u */
+    v2 = TH_CONTROL_PHASE(pb);                    /* - 0 s a 0 0 0 0 - 1 c b m x y z */
+    val = TH_CONTROL_PHASE(pb);                   /* - 0 s a 1 1 x x - 1 c b r l d u */
+                                                  /* x should be read as 1 on a 6 button controller but in some case we read 0 so take care of that */
+    Z80_STATE_RESTORE
+
+    // On a six-button controller, bits 0-3 of the high byte will always read 0.
+    // This corresponds to up + down on a 3-button controller, on some controller or emulator that is a possible combination so we try
+    // to compensante using last TH low read which should return 1111 on 6 buttons controller (not 100% though).
+    if (((v2 & 0x0F00) != 0x0000) || ((val & 0x0C00) == 0x0000)) v2 = (JOY_TYPE_PAD3 << JOY_TYPE_SHIFT) | 0x0F00; /* three button pad */
+    else v2 = (JOY_TYPE_PAD6 << JOY_TYPE_SHIFT) | ((v2 & 0x000F) << 8); /* six button pad */
+
+    val = ((v1 & 0x3000) >> 6) | (v1 & 0x003F);   /* 0 0 0 0 0 0 0 0 s a c b r l d u  */
+    val |= v2;                                    /* 0 0 0 1 m x y z s a c b r l d u  or  0 0 0 0 1 1 1 1 s a c b r l d u */
+    val ^= 0x0FFF;                                /* 0 0 0 1 M X Y Z S A C B R L D U  or  0 0 0 0 0 0 0 0 S A C B R L D U */
+
+    return val;
+}
+
+static s16 start3lhs(u16 port, u8 *hdr, u16 len)
+{
+    vu8 *pb;
+    u16 i;
+    Z80_STATE_DECL
+
+    retry = 255;
+    phase = 0x20; /* selected */
+
+    Z80_STATE_SAVE
+
+    /* make sure port direction is correct */
+    pb = (vu8 *)0xa10009 + port*2;
+    *pb = 0x60;
+
+    /* make sure port is deselected to start at first phase */
+    pb = (vu8 *)0xa10003 + port*2;
+    *pb = 0x60;
+    asm volatile ("nop");
+    asm volatile ("nop");
+
+    /* quick check for at least initial mouse/tap value to cut the amount
+     * of time spent if a mouse/tap isn't really plugged in, but the game
+     * still activates the support
+     */
+    i = *pb & 0x0F;
+    if ((i != 0) && (i != 3))
+    {
+        Z80_STATE_RESTORE
+        return -1;
+    }
+
+    hdr[0] = THREELINE_HANDSHAKE(pb, 0x60);
+    if (retry)
+    {
+        for (i = 1; i < len; i++)
+        {
+            hdr[i] = THREELINE_HANDSHAKE(pb, phase);
+            phase ^= 0x20;
+            if (!retry) break; /* timeout */
+        }
+    }
+
+    if (!retry) *pb = 0x60; /* timeout - end request */
+
+    Z80_STATE_RESTORE
+
+    return retry ? 0 : -1;
+}
+
+
+static u16 readMouse(u16 port)
+{
+    vu8 *pb;
+    u16 val, i, mx, my;
+    s16 sts;
+    u8 hdr[4], md[6];
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+    val = (JOY_TYPE_MOUSE << JOY_TYPE_SHIFT);
+
+    sts = start3lhs(port, hdr, 4);
+
+    // only need to check 2 first nibbles
+    if ((sts == 0) &&
+        (hdr[0] == 0x00) &&
+        (hdr[1] == 0x0B))
+//    if ((sts == 0) &&
+//        (hdr[0] == 0x00) &&
+//        (hdr[1] == 0x0B) &&
+//        (hdr[2] == 0x0F) &&
+//        (hdr[3] == 0x0F))
+    {
+
+        Z80_STATE_SAVE
+        /* handle mouse */
+        for (i=0; i<6; i++)
+        {
+            md[i] = THREELINE_HANDSHAKE(pb, phase);
+            phase ^= 0x20;
+            if (!retry)
+                break; /* timeout */
+        }
+        Z80_STATE_RESTORE
+
+        if (i == 6)
+        {
+            if (md[0] & 0x04)
+                mx = 256; /* x overflow */
+            else
+                mx = md[2]<<4 | md[3];
+            if (md[0] & 0x01)
+                mx |= mx ? 0xFF00 : 0xFFFF; /* x sign extend */
+            if (md[0] & 0x08)
+                my = 256; /* y overflow */
+            else
+                my = md[4]<<4 | md[5];
+            if (md[0] & 0x02)
+                my |= my ? 0xFF00 : 0xFFFF; /* y sign extend */
+            joyAxisX[port] += (s16)mx;
+            joyAxisY[port] -= (s16)my;
+
+            if (md[1] & 8) val |= BUTTON_START;
+            if (md[1] & 4) val |= BUTTON_MMB;
+            if (md[1] & 2) val |= BUTTON_RMB;
+            if (md[1] & 1) val |= BUTTON_LMB;
+
+            if ((s16)mx < -2) val |= BUTTON_LEFT;
+            else if ((s16)mx > 2) val |= BUTTON_RIGHT;
+            if ((s16)my < -2) val |= BUTTON_DOWN;
+            else if ((s16)my > 2) val |= BUTTON_UP;
+        }
+    }
+
+    Z80_STATE_SAVE
+    *pb = 0x60; /* end request */
+    Z80_STATE_RESTORE
+
+    return val;
+}
+
+static void readTeamPlayer(u16 port)
+{
+    static const u16 xlt_all[2][4] =
+    {
+        { JOY_1, JOY_3, JOY_4, JOY_5 },
+        { JOY_2, JOY_6, JOY_7, JOY_8 }
+    };
+
+    vu8 *pb;
+    u16 val = 0, v1 = 0, v2 = 0, v3 = 0;
+    u16 mx, my, typ = JOY_TYPE_UNKNOWN, i, j;
+    s16 sts;
+    u16 change;
+    u8 hdr[8], md[6];
+    const u16 *xlt_port = xlt_all[port];
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+
+    sts = start3lhs(port, hdr, 8);
+
+    // TeamPlayer ?
+    if ((sts == 0) && (hdr[0] == 0x03) && (hdr[1] == 0x0F) && (hdr[2] == 0x00) && (hdr[3] == 0x00))
+    {
+        /* handle Sega Tap */
+        for (j = 0; j < 4; j++)
+        {
+            const u16 xlt = xlt_port[j];
+
+            switch(hdr[4 + j])
+            {
+                case JOY_TYPE_UNKNOWN:
+                    val = 0;
+                    typ = JOY_TYPE_UNKNOWN;
+                    break;
+
+                case JOY_TYPE_PAD3:
+                    Z80_STATE_SAVE
+                    v1 = THREELINE_HANDSHAKE(pb, phase); /* r l d u */
+                    phase ^= 0x20;
+                    if (retry)
+                    {
+                        v2 = THREELINE_HANDSHAKE(pb, phase); /* s a c b */
+                        phase ^= 0x20;
+                    }
+                    Z80_STATE_RESTORE
+                    if (!retry) break; /* timeout */
+
+                    val = (v2 << 4) | v1;
+                    val ^= 0x00FF; /* 0 0 0 0 0 0 0 0 S A C B R L D U */
+                    typ = JOY_TYPE_PAD3;
+                    break;
+
+                case JOY_TYPE_PAD6:
+                    Z80_STATE_SAVE
+                    v1 = THREELINE_HANDSHAKE(pb, phase); /* r l d u */
+                    phase ^= 0x20;
+                    if (retry)
+                    {
+                        v2 = THREELINE_HANDSHAKE(pb, phase); /* s a c b */
+                        phase ^= 0x20;
+                        if (retry)
+                        {
+                            v3 = THREELINE_HANDSHAKE(pb, phase); /* m x y z */
+                            phase ^= 0x20;
+                        }
+                    }
+                    Z80_STATE_RESTORE
+                    if (!retry) break; /* timeout */
+
+                    val = (v3 << 8) | (v2 << 4) | v1;
+                    val ^= 0x0FFF; /* 0 0 0 1 M X Y Z S A C B R L D U */
+                    typ = JOY_TYPE_PAD6;
+                    break;
+
+                case JOY_TYPE_MOUSE:
+                    Z80_STATE_SAVE
+                    for (i=0; i<6; i++)
+                    {
+                        md[i] = THREELINE_HANDSHAKE(pb, phase);
+                        phase ^= 0x20;
+                        if (!retry) break; /* timeout */
+                    }
+                    Z80_STATE_RESTORE
+                    if (!retry) break;
+
+                    val = 0;
+                    if (md[0] & 0x04) mx = 256; /* x overflow */
+                    else mx = (md[2] << 4) | md[3];
+                    if (md[0] & 0x01) mx |= 0xFF00; /* x sign extend */
+                    if (md[0] & 0x08) my = 256; /* y overflow */
+                    else my = (md[4] << 4) | md[5];
+                    if (md[0] & 0x02) my |= 0xFF00; /* y sign extend */
+                    joyAxisX[xlt] += (s16)mx;
+                    joyAxisY[xlt] += (s16)my;
+
+                    if (md[1] & 8) val |= BUTTON_START;
+                    if (md[1] & 4) val |= BUTTON_MMB;
+                    if (md[1] & 2) val |= BUTTON_RMB;
+                    if (md[1] & 1) val |= BUTTON_LMB;
+
+                    if ((s16)mx < -2) val |= BUTTON_LEFT;
+                    else if ((s16)mx > 2) val |= BUTTON_RIGHT;
+                    if ((s16)my < -2) val |= BUTTON_DOWN;
+                    else if ((s16)my > 2) val |= BUTTON_UP;
+
+                    typ = JOY_TYPE_MOUSE;
+                    break;
+            }
+
+            if (!retry) break; /* timeout */
+
+            joyType[xlt] = typ;
+            change = joyState[xlt] ^ val;
+            joyState[xlt] = val;
+            if (joyEventCB && change) joyEventCB(xlt, change, val);
+        }
+    }
+
+    Z80_STATE_SAVE
+    *pb = 0x60; /* end request */
+    Z80_STATE_RESTORE
+}
+
+static void readEa4WayPlay()
+{
+    static const u16 xlt[4] = { JOY_1, JOY_3, JOY_4, JOY_5 };
+
+    vu8 *pb;
+    u16 change;
+    u16 val, v1, v2, typ, ind, i;
+    Z80_STATE_DECL
+
+    for (i=0; i<4; i++)
+    {
+        pb = (vu8 *)0xa10005;
+
+        Z80_STATE_SAVE
+
+        *pb = (i<<4) | 0x0C;                          /* select port i */
+
+        pb = (vu8 *)0xa10003;
+        v1 = TH_CONTROL_PHASE(pb);                    /* - 0 s a 0 0 d u - 1 c b r l d u */
+
+        if (v1 & 0x0C00)
+        {
+            Z80_STATE_RESTORE
+            continue;                                 /* no pad */
+        }
+
+        val = TH_CONTROL_PHASE(pb);                   /* - 0 s a 0 0 d u - 1 c b r l d u */
+        v2 = TH_CONTROL_PHASE(pb);                    /* - 0 s a 0 0 0 0 - 1 c b m x y z */
+        val = TH_CONTROL_PHASE(pb);                   /* - 0 s a 1 1 1 1 - 1 c b r l d u */
+
+        pb = (vu8 *)0xa10005;
+        *pb = 0x7C;                                   /* deselect port */
+
+        Z80_STATE_RESTORE
+
+        if ((val & 0x0F00) != 0x0F00)
+        {
+            typ = JOY_TYPE_PAD3;                      /* three button pad */
+            v2 = 0x0F00;
+        }
+        else
+        {
+            typ = JOY_TYPE_PAD6;                      /* six button pad */
+            v2 = (v2 & 0x000F) << 8;
+        }
+
+        val = ((v1 & 0x3000) >> 6) | (v1 & 0x003F);   /* 0 0 0 0 0 0 0 0 s a c b r l d u  */
+        val |= v2;                                    /* 0 0 0 1 m x y z s a c b r l d u  or  0 0 0 0 1 1 1 1 s a c b r l d u */
+        val ^= 0x0FFF;                                /* 0 0 0 1 M X Y Z S A C B R L D U  or  0 0 0 0 0 0 0 0 S A C B R L D U */
+
+        ind = xlt[i];
+
+        joyType[ind] = typ;
+        change = joyState[ind] ^ val;
+        joyState[ind] = val;
+        if (joyEventCB && change) joyEventCB(ind, change, val);
+    }
+}
+
+static void readLightgun(u16 port)
+{
+    vu8 *pb;
+    u16 newstate, change;
+    u16 val = 0;
+    u32 tmp;
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+    if (portType[port] == PORT_TYPE_JUSTIFIER)
+    {
+        Z80_STATE_SAVE
+        *pb = gun | 0x10;                   /* deselect gun */
+        Z80_STATE_RESTORE
+    }
+
+    if (!extSet)
+    {
+        /* no light sense => gun not pointed at screen */
+        if (!gun)
+        {
+            /* blue gun or menacer or phaser*/
+            joyAxisX[port] = -1;
+            joyAxisY[port] = -1;
+        }
+        else
+        {
+            /* red gun */
+            joyAxisX[port ? JOY_6 : JOY_3] = -1;
+            joyAxisY[port ? JOY_6 : JOY_3] = -1;
+        }
+    }
+
+    if (portType[port] == PORT_TYPE_MENACER)
+    {
+        asm volatile ("move.w #160,%0\n"
+            "1:\n\t"
+            "dbra %0,1b\n\t"
+            : "=d" (tmp) : : "cc"
+        );
+        Z80_STATE_SAVE
+        *pb = 0xFF;                         /* deassert RST */
+        Z80_STATE_RESTORE
+        asm volatile ("moveq #20,%0\n"
+            "1:\n\t"
+            "dbra %0,1b\n\t"
+            : "=d" (tmp) : : "cc"
+        );
+        Z80_STATE_SAVE
+        *pb = 0xDF;                         /* assert RST long */
+        Z80_STATE_RESTORE
+        asm volatile ("moveq #60,%0\n"
+            "1:\n\t"
+            "dbra %0,1b\n\t"
+            : "=d" (tmp) : : "cc"
+        );
+        Z80_STATE_SAVE
+        *pb = 0xFF;                         /* deassert RST */
+        asm volatile ("nop");
+        *pb = 0xDF;                         /* assert RST long */
+        Z80_STATE_RESTORE
+        asm volatile ("move.w #1080,%0\n"
+            "1:\n\t"
+            "dbra %0,1b\n\t"
+            : "=d" (tmp) : : "cc"
+        );
+        Z80_STATE_SAVE
+        val = *pb;
+        *pb = 0xFF;                         /* deassert RST */
+        asm volatile ("nop");
+        *pb = 0xCF;                         /* assert RST short - clear counter */
+        Z80_STATE_RESTORE
+
+        newstate = 0;
+        if (val & 8) newstate |= BUTTON_START;
+        if (val & 4) newstate |= BUTTON_C;
+        if (val & 2) newstate |= BUTTON_A;
+        if (val & 1) newstate |= BUTTON_B;
+
+        change = joyState[port] ^ newstate;
+        joyType[port] = JOY_TYPE_MENACER;
+        joyState[port] = newstate;
+        if (joyEventCB && change) joyEventCB(port, change, newstate);
+    }
+    else if (portType[port] == PORT_TYPE_JUSTIFIER)
+    {
+        Z80_STATE_SAVE
+        *pb = 0x00;                         /* select blue gun */
+        val = *pb;
+        val = *pb;                          /* read twice... probably a setup delay thing */
+        *pb = 0x10;                         /* deselect blue gun */
+        Z80_STATE_RESTORE
+
+        newstate = 0;
+        if (~val & 2) newstate |= BUTTON_START;
+        if (~val & 1) newstate |= BUTTON_A;
+
+        change = joyState[port] ^ newstate;
+        joyType[port] = JOY_TYPE_JUSTIFIER;
+        joyState[port] = newstate;
+        if (joyEventCB && change) joyEventCB(port, change, newstate);
+
+        if (joyType[port ? JOY_6 : JOY_3] == JOY_TYPE_JUSTIFIER)
+        {
+            Z80_STATE_SAVE
+            *pb = 0x20;                     /* select red gun */
+            val = *pb;
+            val = *pb;                      /* read twice... probably a setup delay thing */
+            *pb = 0x30;                     /* deselect red gun */
+            Z80_STATE_RESTORE
+
+            newstate = 0;
+            if (~val & 2) newstate |= BUTTON_START;
+            if (~val & 1) newstate |= BUTTON_A;
+
+            change = joyState[port ? JOY_6 : JOY_3] ^ newstate;
+            joyType[port ? JOY_6 : JOY_3] = JOY_TYPE_JUSTIFIER;
+            joyState[port ? JOY_6 : JOY_3] = newstate;
+            if (joyEventCB && change) joyEventCB(port ? JOY_6 : JOY_3, change, newstate);
+
+            /* only need to toggle gun selector if have two guns */
+            gun ^= 0x20;
+        }
+
+        Z80_STATE_SAVE
+        *pb = gun | 0x10;                   /* deselect gun */
+        *pb = gun;                          /* leave gun selected to get light sense input */
+        Z80_STATE_RESTORE
+    }
+    else
+    {
+        /* check Phaser trigger */
+        Z80_STATE_SAVE
+        val = *pb;                          /* - - - t - - - - */
+        Z80_STATE_RESTORE
+
+        newstate = 0;
+        if (~val & 0x10) newstate = BUTTON_A;
+
+        change = joyState[port] ^ newstate;
+        joyType[port] = JOY_TYPE_PHASER;
+        joyState[port] = newstate;
+        if (joyEventCB && change) joyEventCB(port, change, newstate);
+    }
+
+    extSet = 0;                             /* clear light sensed flag */
+}
+
+static u16 readTrackball(u16 port)
+{
+    vu8 *pb;
+    u8 mx, my, v1, v2, v3, v4;
+    u16 val;
+    u32 tmp;
+    Z80_STATE_DECL
+
+    pb = (vu8 *)0xa10003 + port*2;
+    val = (JOY_TYPE_TRACKBALL << JOY_TYPE_SHIFT);
+
+    Z80_STATE_SAVE
+    *pb = 0x00; /* TH (select) low */
+    Z80_STATE_RESTORE
+    /* ~ 84 us */
+    asm volatile ("moveq #63,%0\n"
+        "1:\n\t"
+        "dbra %0,1b\n\t"
+        : "=d" (tmp) : : "cc"
+    );
+    Z80_STATE_SAVE
+    v1 = *pb;
+    *pb = 0x40; /* TH (select) high */
+    Z80_STATE_RESTORE
+    /* ~ 42 us */
+    asm volatile ("moveq #31,%0\n"
+        "1:\n\t"
+        "dbra %0,1b\n\t"
+        : "=d" (tmp) : : "cc"
+    );
+    Z80_STATE_SAVE
+    v2 = *pb;
+    *pb = 0x00; /* TH (select) low */
+    Z80_STATE_RESTORE
+    /* ~ 42 us */
+    asm volatile ("moveq #31,%0\n"
+        "1:\n\t"
+        "dbra %0,1b\n\t"
+        : "=d" (tmp) : : "cc"
+    );
+    Z80_STATE_SAVE
+    v3 = *pb;
+    *pb = 0x40; /* TH (select) high */
+    Z80_STATE_RESTORE
+    /* ~ 42 us */
+    asm volatile ("moveq #31,%0\n"
+        "1:\n\t"
+        "dbra %0,1b\n\t"
+        : "=d" (tmp) : : "cc"
+    );
+    Z80_STATE_SAVE
+    v4 = *pb;
+    Z80_STATE_RESTORE
+
+    mx = (v1 & 0x0F) << 4;
+    mx |= v2 & 0x0F;
+    my = (v3 & 0x0F) << 4;
+    my |= v4 & 0x0F;
+
+    joyAxisX[port] -= (s8)mx;
+    joyAxisY[port] += (s8)my;
+
+    if (~v4 & 32) val |= BUTTON_A;
+    if (~v4 & 16) val |= BUTTON_START;
+    if ((s8) mx < -2) val |= BUTTON_RIGHT;
+    else if ((s8) mx > 2) val |= BUTTON_LEFT;
+    if ((s8) my < -2) val |= BUTTON_DOWN;
+    else if ((s8) my > 2) val |= BUTTON_UP;
+
+    return val;
+}
+
+
+NO_INLINE void JOY_update()
+{
+    u16 support;
+    u16 val;
+    u16 newstate;
+    u16 change;
+
+    SYS_disableInts();
+
+    support = portSupport[PORT_1];
+    switch (support)
+    {
+        default:
+        case JOY_SUPPORT_OFF:
+            break;
+
+        case JOY_SUPPORT_3BTN:
+            val = read3Btn(PORT_1);
+            break;
+
+        case JOY_SUPPORT_6BTN:
+            val = read6Btn(PORT_1);
+            break;
+
+        case JOY_SUPPORT_MOUSE:
+            val = readMouse(PORT_1);
+            break;
+
+        case JOY_SUPPORT_TRACKBALL:
+            val = readTrackball(PORT_1);
+            break;
+
+        case JOY_SUPPORT_TEAMPLAYER:
+            readTeamPlayer(PORT_1);
+            break;
+
+        case JOY_SUPPORT_EA4WAYPLAY:
+            readEa4WayPlay();
+            break;
+
+        case JOY_SUPPORT_MENACER:
+        case JOY_SUPPORT_JUSTIFIER_BLUE:
+        case JOY_SUPPORT_JUSTIFIER_BOTH:
+        case JOY_SUPPORT_PHASER:
+            readLightgun(PORT_1);
+            break;
+    }
+
+    if ((support > JOY_SUPPORT_OFF) && (support < JOY_SUPPORT_TEAMPLAYER))
+    {
+        newstate = val & BUTTON_ALL;
+        change = joyState[JOY_1] ^ newstate;
+        joyType[JOY_1] = val >> JOY_TYPE_SHIFT;
+        joyState[JOY_1] = newstate;
+        if (joyEventCB && change) joyEventCB(JOY_1, change, newstate);
+    }
+
+    support = portSupport[PORT_2];
+    switch (support)
+    {
+        default:
+        case JOY_SUPPORT_OFF:
+            break;
+
+        case JOY_SUPPORT_3BTN:
+            val = read3Btn(PORT_2);
+            break;
+
+        case JOY_SUPPORT_6BTN:
+            val = read6Btn(PORT_2);
+            break;
+
+        case JOY_SUPPORT_MOUSE:
+            val = readMouse(PORT_2);
+            break;
+
+        case JOY_SUPPORT_TRACKBALL:
+            val = readTrackball(PORT_2);
+            break;
+
+        case JOY_SUPPORT_TEAMPLAYER:
+            readTeamPlayer(PORT_2);
+            break;
+
+        case JOY_SUPPORT_MENACER:
+        case JOY_SUPPORT_JUSTIFIER_BLUE:
+        case JOY_SUPPORT_JUSTIFIER_BOTH:
+        case JOY_SUPPORT_PHASER:
+            readLightgun(PORT_2);
+            break;
+    }
+
+    if ((support > JOY_SUPPORT_OFF) && (support < JOY_SUPPORT_TEAMPLAYER))
+    {
+        newstate = val & BUTTON_ALL;
+        change = joyState[JOY_2] ^ newstate;
+        joyType[JOY_2] = val >> JOY_TYPE_SHIFT;
+        joyState[JOY_2] = newstate;
+        if (joyEventCB && change) joyEventCB(JOY_2, change, newstate);
+    }
+
+    /* restore ints */
+    SYS_enableInts();
+
+    // random seed not yet set ?
+    if (!randomSeedSet)
+    {
+        // button pressed ? --> set random seed from elapsed time (using tick is enough)
+        if (joyState[JOY_1] || joyState[JOY_2])
+        {
+            u16 tick = getTick();
+            setRandomSeed((tick << 0) ^ (tick << 8));
+        }
+    }
+}