Index: trunk/src/VBox/Devices/Input/DevPS2.cpp
===================================================================
--- trunk/src/VBox/Devices/Input/DevPS2.cpp	(revision 48195)
+++ trunk/src/VBox/Devices/Input/DevPS2.cpp	(revision 48214)
@@ -54,5 +54,5 @@
 #include "PS2Dev.h"
 
-#define PCKBD_SAVED_STATE_VERSION 6
+#define PCKBD_SAVED_STATE_VERSION 7
 
 
@@ -119,4 +119,5 @@
 #define KBD_MODE_RFU            0x80
 
+#ifndef VBOX_WITH_NEW_PS2M
 /* Mouse Commands */
 #define AUX_SET_SCALE11         0xE6    /* Set 1:1 scaling */
@@ -173,4 +174,5 @@
     int     count;
 } MouseEventQueue;
+#endif
 
 /**
@@ -181,6 +183,8 @@
 typedef struct KBDState
 {
+#ifndef VBOX_WITH_NEW_PS2M
     MouseCmdQueue mouse_command_queue;
     MouseEventQueue mouse_event_queue;
+#endif
     uint8_t write_cmd; /* if non zero, write data to port 60 is expected */
     uint8_t status;
@@ -190,4 +194,5 @@
     int32_t translate;
     int32_t xlat_state;
+#ifndef VBOX_WITH_NEW_PS2M
     /* mouse state */
     int32_t mouse_write_cmd;
@@ -205,4 +210,5 @@
     uint8_t mouse_buttons;
     uint8_t mouse_buttons_reported;
+#endif
 
     uint32_t    Alignment0;
@@ -222,4 +228,12 @@
 #endif
 
+#ifdef VBOX_WITH_NEW_PS2M
+    /** Mouse state (implemented in separate PS2M module). */
+#ifdef VBOX_DEVICE_STRUCT_TESTCASE
+    uint8_t                     AuxFiller[PS2M_STRUCT_FILLER];
+#else
+    PS2M                        Aux;
+#endif
+#else
     /**
      * Mouse port - LUN#1.
@@ -240,4 +254,5 @@
         R3PTRTYPE(PPDMIMOUSECONNECTOR)      pDrv;
     } Mouse;
+#endif
 } KBDState;
 
@@ -247,6 +262,8 @@
 static void kbd_update_irq(KBDState *s)
 {
+#ifndef VBOX_WITH_NEW_PS2M
     MouseCmdQueue *mcq = &s->mouse_command_queue;
     MouseEventQueue *meq = &s->mouse_event_queue;
+#endif
     int irq12_level, irq1_level;
     uint8_t val;
@@ -292,4 +309,11 @@
             }
         }
+#ifdef VBOX_WITH_NEW_PS2M
+        else if (!(s->mode & KBD_MODE_DISABLE_MOUSE) && PS2MByteFromAux(&s->Aux, &val) == VINF_SUCCESS)
+        {
+            s->dbbout = val;
+            s->status |= KBD_STAT_OBF | KBD_STAT_MOUSE_OBF;
+        }
+#else
         else if ((mcq->count || meq->count) && !(s->mode & KBD_MODE_DISABLE_MOUSE))
         {
@@ -310,4 +334,5 @@
             }
         }
+#endif
     }
     /* Determine new IRQ state. */
@@ -334,4 +359,5 @@
 }
 
+#ifndef VBOX_WITH_NEW_PS2M
 static void kbd_queue(KBDState *s, int b, int aux)
 {
@@ -375,4 +401,5 @@
     kbd_update_irq(s);
 }
+#endif
 
 static void kbc_dbb_out(void *opaque, uint8_t val)
@@ -385,4 +412,15 @@
     if (s->mode & KBD_MODE_KBD_INT)
         PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 1, 1);
+}
+
+static void kbc_dbb_out_aux(void *opaque, uint8_t val)
+{
+    KBDState *s = (KBDState*)opaque;
+
+    s->dbbout = val;
+    /* Set the aux OBF and raise IRQ. */
+    s->status |= KBD_STAT_OBF | KBD_STAT_MOUSE_OBF;
+    if (s->mode & KBD_MODE_MOUSE_INT)
+        PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 12, PDM_IRQ_LEVEL_HIGH);
 }
 
@@ -557,4 +595,15 @@
 }
 
+PS2M *KBDGetPS2MFromDevIns(PPDMDEVINS pDevIns)
+{
+    KBDState *pThis = PDMINS_2_DATA(pDevIns, KBDState *);
+#ifdef VBOX_WITH_NEW_PS2M
+    return &pThis->Aux;
+#else
+    return NULL;
+#endif
+}
+
+#ifndef VBOX_WITH_NEW_PS2M
 static void kbd_mouse_set_reported_buttons(KBDState *s, unsigned fButtons, unsigned fButtonMask)
 {
@@ -914,4 +963,5 @@
     return rc;
 }
+#endif
 
 static int kbd_write_data(void *opaque, uint32_t addr, uint32_t val)
@@ -942,5 +992,5 @@
         break;
     case KBD_CCMD_WRITE_AUX_OBUF:
-        kbd_queue(s, val, 1);
+        kbc_dbb_out_aux(s, val);
         break;
     case KBD_CCMD_WRITE_OUTPORT:
@@ -964,5 +1014,11 @@
         /* Automatically enables aux interface. */
         s->mode &= ~KBD_MODE_DISABLE_MOUSE;
+#ifdef VBOX_WITH_NEW_PS2M
+        rc = PS2MByteToAux(&s->Aux, val);
+        if (rc == VINF_SUCCESS)
+            kbd_update_irq(s);
+#else
         rc = kbd_write_mouse(s, val);
+#endif
         break;
     default:
@@ -979,8 +1035,10 @@
 {
     KBDState *s = (KBDState*)opaque;
+#ifndef VBOX_WITH_NEW_PS2M
     MouseCmdQueue *mcq;
     MouseEventQueue *meq;
 
     s->mouse_write_cmd = -1;
+#endif
     s->mode = KBD_MODE_KBD_INT | KBD_MODE_MOUSE_INT;
     s->status = KBD_STAT_CMD | KBD_STAT_UNLOCKED;
@@ -988,4 +1046,5 @@
     s->write_cmd = 0;
     s->translate = 0;
+#ifndef VBOX_WITH_NEW_PS2M
     if (s->mouse_status)
     {
@@ -1013,10 +1072,13 @@
     meq->wptr = 0;
     meq->count = 0;
+#endif
 }
 
 static void kbd_save(QEMUFile* f, void* opaque)
 {
+#ifndef VBOX_WITH_NEW_PS2M
     uint32_t    cItems;
     int i;
+#endif
     KBDState *s = (KBDState*)opaque;
 
@@ -1025,4 +1087,5 @@
     qemu_put_8s(f, &s->mode);
     qemu_put_8s(f, &s->dbbout);
+#ifndef VBOX_WITH_NEW_PS2M
     qemu_put_be32s(f, &s->mouse_write_cmd);
     qemu_put_8s(f, &s->mouse_status);
@@ -1051,4 +1114,5 @@
         SSMR3PutU8(f, s->mouse_event_queue.data[i]);
     Log(("kbd_save: %d mouse event queue items stored\n", s->mouse_event_queue.count));
+#endif
 
     /* terminator */
@@ -1084,4 +1148,5 @@
         qemu_get_8s(f, &s->dbbout);
     }
+#ifndef VBOX_WITH_NEW_PS2M
     qemu_get_be32s(f, (uint32_t *)&s->mouse_write_cmd);
     qemu_get_8s(f, &s->mouse_status);
@@ -1115,4 +1180,5 @@
     s->mouse_event_queue.rptr = 0;
     s->mouse_event_queue.wptr = 0;
+#endif
 
     /* Determine the translation state. */
@@ -1136,4 +1202,5 @@
     }
 
+#ifndef VBOX_WITH_NEW_PS2M
     rc = SSMR3GetU32(f, &u32);
     if (RT_FAILURE(rc))
@@ -1171,4 +1238,19 @@
     s->mouse_event_queue.count = u32;
     Log(("kbd_load: %d mouse event queue items loaded\n", u32));
+#else
+    if (version_id <= 6)
+    {
+        rc = SSMR3GetU32(f, &u32);
+        if (RT_FAILURE(rc))
+            return rc;
+        for (i = 0; i < u32; i++)
+        {
+            rc = SSMR3GetU8(f, &u8Dummy);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+        Log(("kbd_load: %d mouse event queue items discarded from old saved state\n", u32));
+    }
+#endif
 
     /* terminator */
@@ -1181,6 +1263,8 @@
         return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
     }
+#ifndef VBOX_WITH_NEW_PS2M
     /* Resend a notification to Main if the device is active */
     kbd_mouse_update_downstream_status(s);
+#endif
     return 0;
 }
@@ -1308,4 +1392,7 @@
     kbd_save(pSSM, pThis);
     PS2KSaveState(&pThis->Kbd, pSSM);
+#ifdef VBOX_WITH_NEW_PS2M
+    PS2MSaveState(&pThis->Aux, pSSM);
+#endif
     return VINF_SUCCESS;
 }
@@ -1330,4 +1417,8 @@
     if (uVersion >= 6)
         rc = PS2KLoadState(&pThis->Kbd, pSSM, uVersion);
+#ifdef VBOX_WITH_NEW_PS2M
+    if (uVersion >= 7)
+        rc = PS2MLoadState(&pThis->Aux, pSSM, uVersion);
+#endif
     return rc;
 }
@@ -1345,7 +1436,11 @@
     kbd_reset(pThis);
     PS2KReset(&pThis->Kbd);
-}
-
-
+#ifdef VBOX_WITH_NEW_PS2M
+    PS2MReset(&pThis->Aux);
+#endif
+}
+
+
+#ifndef VBOX_WITH_NEW_PS2M
 /* -=-=-=-=-=- Mouse: IBase  -=-=-=-=-=- */
 
@@ -1403,5 +1498,5 @@
     NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
 }
-
+#endif
 
 /* -=-=-=-=-=- real code -=-=-=-=-=- */
@@ -1444,4 +1539,7 @@
         /* LUN #1: aux/mouse */
         case 1:
+#ifdef VBOX_WITH_NEW_PS2M
+            rc = PS2MAttach(&pThis->Aux, pDevIns, iLUN, fFlags);
+#else
             rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Mouse.IBase, &pThis->Mouse.pDrvBase, "Aux (Mouse) Port");
             if (RT_SUCCESS(rc))
@@ -1461,4 +1559,5 @@
             else
                 AssertLogRelMsgFailed(("Failed to attach LUN #1! rc=%Rrc\n", rc));
+#endif
             break;
 
@@ -1526,4 +1625,7 @@
     pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     PS2KRelocate(&pThis->Kbd, offDelta, pDevIns);
+#ifdef VBOX_WITH_NEW_PS2M
+    PS2MRelocate(&pThis->Aux, offDelta, pDevIns);
+#endif
 }
 
@@ -1553,4 +1655,5 @@
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"R0Enabled\" from the config"));
+fGCEnabled = fR0Enabled = false;
     Log(("pckbd: fGCEnabled=%RTbool fR0Enabled=%RTbool\n", fGCEnabled, fR0Enabled));
 
@@ -1567,8 +1670,14 @@
         return rc;
 
+#ifdef VBOX_WITH_NEW_PS2M
+    rc = PS2MConstruct(&pThis->Aux, pDevIns, pThis, iInstance);
+    if (RT_FAILURE(rc))
+        return rc;
+#else
     pThis->Mouse.IBase.pfnQueryInterface    = kbdMouseQueryInterface;
     pThis->Mouse.IPort.pfnPutEvent          = kbdMousePutEvent;
     pThis->Mouse.IPort.pfnPutEventAbs       = kbdMousePutEventAbs;
     pThis->Mouse.IPort.pfnPutEventMultiTouch = kbdMousePutEventMultiTouch;
+#endif
 
     /*
Index: trunk/src/VBox/Devices/Input/PS2Dev.h
===================================================================
--- trunk/src/VBox/Devices/Input/PS2Dev.h	(revision 48195)
+++ trunk/src/VBox/Devices/Input/PS2Dev.h	(revision 48214)
@@ -18,8 +18,9 @@
 #define PS2DEV_H
 
-/** The size of the PS2K structure filler.
+/** The size of the PS2K/PS2M structure fillers.
  * @note Must be at least as big as the real struct. Compile time assert
  *       makes sure this is so. */
 #define PS2K_STRUCT_FILLER  512
+#define PS2M_STRUCT_FILLER  512
 
 /* Hide the internal structure. */
@@ -31,4 +32,12 @@
 #endif
 
+#if !(defined(IN_PS2M) || defined(VBOX_DEVICE_STRUCT_TESTCASE))
+typedef struct PS2M
+{
+    uint8_t     abFiller[PS2M_STRUCT_FILLER];
+} PS2M;
+#endif
+
+/* Internal PS/2 Keyboard interface. */
 typedef struct PS2K *PPS2K;
 
@@ -43,7 +52,26 @@
 int  PS2KLoadState(PPS2K pThis, PSSMHANDLE pSSM, uint32_t uVersion);
 
+PS2K *KBDGetPS2KFromDevIns(PPDMDEVINS pDevIns);
+
+
+/* Internal PS/2 Auxiliary device interface. */
+typedef struct PS2M *PPS2M;
+
+int  PS2MByteToAux(PPS2M pThis, uint8_t cmd);
+int  PS2MByteFromAux(PPS2M pThis, uint8_t *pVal);
+
+int  PS2MConstruct(PPS2M pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance);
+int  PS2MAttach(PPS2M pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags);
+void PS2MReset(PPS2M pThis);
+void PS2MRelocate(PPS2M pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns);
+void PS2MSaveState(PPS2M pThis, PSSMHANDLE pSSM);
+int  PS2MLoadState(PPS2M pThis, PSSMHANDLE pSSM, uint32_t uVersion);
+
+PS2M *KBDGetPS2MFromDevIns(PPDMDEVINS pDevIns);
+
+
+/* Shared keyboard/aux internal interface. */
 void KBCUpdateInterrupts(void *pKbc);
 
-PS2K *KBDGetPS2KFromDevIns(PPDMDEVINS pDevIns);
 
 ///@todo: This should live with the KBC implementation.
Index: trunk/src/VBox/Devices/Input/PS2M.cpp
===================================================================
--- trunk/src/VBox/Devices/Input/PS2M.cpp	(revision 48214)
+++ trunk/src/VBox/Devices/Input/PS2M.cpp	(revision 48214)
@@ -0,0 +1,1134 @@
+/** @file
+ * PS2M - PS/2 auxiliary device (mouse) emulation.
+ */
+
+/*
+ * Copyright (C) 2007-2013 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+/*
+ * References:
+ *
+ * The Undocumented PC (2nd Ed.), Frank van Gilluwe, Addison-Wesley, 1996.
+ * IBM TrackPoint System Version 4.0 Engineering Specification, 1999.
+ * ELAN Microelectronics eKM8025 USB & PS/2 Mouse Controller, 2006.
+ *
+ *
+ * Notes:
+ *
+ *  - The auxiliary device commands are very similar to keyboard commands.
+ *    Most keyboard commands which do not specifically deal with the keyboard
+ *    (enable, disable, reset) have identical counterparts.
+ *  - The code refers to 'auxiliary device' and 'mouse'; these terms are not
+ *    quite interchangeable. 'Auxiliary device' is used when referring to the
+ *    generic PS/2 auxiliary device interface and 'mouse' when referring to
+ *    a mouse attached to the auxiliary port.
+ *  - The basic modes of operation are reset, stream, and remote. Those are
+ *    mutually exclusive. Stream and remote modes can additionally have wrap
+ *    mode enabled.
+ *  - The auxiliary device sends unsolicited data to the host only when it is
+ *    both in stream mode and enabled. Otherwise it only responds to commands.
+ *
+ *
+ * There are three report packet formats supported by the emulated device. The
+ * standard three-byte PS/2 format (with middle button support), IntelliMouse
+ * four-byte format with added scroll wheel, and IntelliMouse Explorer four-byte
+ * format with reduced scroll wheel range but two additional buttons. Note that
+ * the first three bytes of the report are always the same.
+ *
+ * Upon reset, the mouse is always in the standard PS/2 mode. A special 'knock'
+ * sequence can be used to switch to ImPS/2 or ImEx mode. Three consecutive
+ * Set Sampling Rate (0F3h) commands with arguments 200, 100, 80 switch to ImPS/2
+ * mode. While in ImPS/2 mode, three consecutive Set Sampling Rate commands with
+ * arguments 200, 200, 80 switch to ImEx mode. The Read ID (0F2h) command will
+ * report the currently selected protocol.
+ *
+ *
+ * Standard PS/2 pointing device three-byte report packet format:
+ *
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * |Bit/byte|  bit 7 |  bit 6 |  bit 5 |  bit 4 |  bit 3 |  bit 2 |  bit 1 |  bit 0 |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * | Byte 1 | Y ovfl | X ovfl | Y sign | X sign |  Sync  | M btn  | R btn  | L btn  |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * | Byte 2 |              X movement delta (two's complement)                      |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * | Byte 3 |              Y movement delta (two's complement)                      |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ *
+ *   - The sync bit is always set. It allows software to synchronize data packets
+ *     as the X/Y position data typically does not have bit 4 set.
+ *   - The overflow bits are set if motion exceeds accumulator range. We use the
+ *     maximum range (effectively 9 bits) and do not set the overflow bits.
+ *   - Movement in the up/right direction is defined as having positive sign.
+ *
+ *
+ * IntelliMouse PS/2 (ImPS/2) fourth report packet byte:
+ *
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * |Bit/byte|  bit 7 |  bit 6 |  bit 5 |  bit 4 |  bit 3 |  bit 2 |  bit 1 |  bit 0 |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * | Byte 4 |              Z movement delta (two's complement)                      |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ *
+ *   - The valid range for Z delta values is only -8/+7, i.e. 4 bits.
+ *
+ * IntelliMouse Explorer (ImEx) fourth report packet byte:
+ *
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * |Bit/byte|  bit 7 |  bit 6 |  bit 5 |  bit 4 |  bit 3 |  bit 2 |  bit 1 |  bit 0 |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ * | Byte 4 |   0    |   0    | Btn 5  | Btn 4  |  Z mov't delta (two's complement) |
+ * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+ *
+ */
+
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#define LOG_GROUP   LOG_GROUP_DEV_KBD
+#include <VBox/vmm/pdmdev.h>
+#include <VBox/err.h>
+#include <iprt/assert.h>
+#include <iprt/uuid.h>
+#include "VBoxDD.h"
+#define IN_PS2M
+#include "PS2Dev.h"
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** @name Auxiliary device commands sent by the system.
+ * @{ */
+#define ACMD_SET_SCALE_11   0xE6    /* Set 1:1 scaling. */
+#define ACMD_SET_SCALE_21   0xE7    /* Set 2:1 scaling. */
+#define ACMD_SET_RES        0xE8    /* Set resolution. */
+#define ACMD_REQ_STATUS     0xE9    /* Get device status. */
+#define ACMD_SET_STREAM     0xEA    /* Set stream mode. */
+#define ACMD_READ_REMOTE    0xEB    /* Read remote data. */
+#define ACMD_RESET_WRAP     0xEC    /* Exit wrap mode. */
+#define ACMD_INVALID_1      0xED
+#define ACMD_SET_WRAP       0xEE    /* Set wrap (echo) mode. */
+#define ACMD_INVALID_2      0xEF
+#define ACMD_SET_REMOTE     0xF0    /* Set remote mode. */
+#define ACMD_INVALID_3      0xF1
+#define ACMD_READ_ID        0xF2    /* Read device ID. */
+#define ACMD_SET_SAMP_RATE  0xF3    /* Set sampling rate. */
+#define ACMD_ENABLE         0xF4    /* Enable (streaming mode). */
+#define ACMD_DFLT_DISABLE   0xF5    /* Disable and set defaults. */
+#define ACMD_SET_DEFAULT    0xF6    /* Set defaults. */
+#define ACMD_INVALID_4      0xF7
+#define ACMD_INVALID_5      0xF8
+#define ACMD_INVALID_6      0xF9
+#define ACMD_INVALID_7      0xFA
+#define ACMD_INVALID_8      0xFB
+#define ACMD_INVALID_9      0xFC
+#define ACMD_INVALID_10     0xFD
+#define ACMD_RESEND         0xFE    /* Resend response. */
+#define ACMD_RESET          0xFF    /* Reset device. */
+/** @} */
+
+/** @name Auxiliary device responses sent to the system.
+ * @{ */
+#define ARSP_ID             0x00
+#define ARSP_BAT_OK         0xAA    /* Self-test passed. */
+#define ARSP_ACK            0xFA    /* Command acknowledged. */
+#define ARSP_ERROR          0xFC    /* Bad command. */
+#define ARSP_RESEND         0xFE    /* Requesting resend. */
+/** @} */
+
+/** Define a simple PS/2 input device queue. */
+#define DEF_PS2Q_TYPE(name, size)   \
+     typedef struct {               \
+        uint32_t    rpos;           \
+        uint32_t    wpos;           \
+        uint32_t    cUsed;          \
+        uint32_t    cSize;          \
+        uint8_t     abQueue[size];  \
+     } name
+
+/* Internal mouse queue sizes. The input queue is relatively large,
+ * but the command queue only needs to handle a few bytes.
+ */
+#define AUX_EVT_QUEUE_SIZE        256
+#define AUX_CMD_QUEUE_SIZE          8
+
+/*******************************************************************************
+*   Structures and Typedefs                                                    *
+*******************************************************************************/
+
+DEF_PS2Q_TYPE(AuxEvtQ, AUX_EVT_QUEUE_SIZE);
+DEF_PS2Q_TYPE(AuxCmdQ, AUX_CMD_QUEUE_SIZE);
+#ifndef VBOX_DEVICE_STRUCT_TESTCASE //@todo: hack
+DEF_PS2Q_TYPE(GeneriQ, 1);
+#endif
+
+/* Auxiliary device special modes of operation. */
+typedef enum {
+    AUX_MODE_STD,           /* Standard operation. */
+    AUX_MODE_RESET,         /* Currently in reset. */
+    AUX_MODE_WRAP           /* Wrap mode (echoing input). */
+} PS2M_MODE;
+
+/* Auxiliary device operational state. */
+typedef enum {
+    AUX_STATE_SCALING = RT_BIT(4),  /* 2:1 scaling in effect. */
+    AUX_STATE_ENABLED = RT_BIT(5),  /* Reporting enabled in stream mode. */
+    AUX_STATE_REMOTE  = RT_BIT(6)   /* Remote mode (reports on request). */
+} PS2M_STATE;
+
+/* Protocols supported by the PS/2 mouse. */
+typedef enum {
+    PS2M_PROTO_PS2STD = 0,  /* Standard PS/2 mouse protocol. */
+    PS2M_PROTO_IMPS2  = 3,  /* IntelliMouse PS/2 protocol. */
+    PS2M_PROTO_IMEX   = 4   /* IntelliMouse Explorer protocol. */
+} PS2M_PROTO;
+
+/* Protocol selection 'knock' states. */
+typedef enum {
+    PS2M_KNOCK_INITIAL,
+    PS2M_KNOCK_IMPS2_1ST,
+    PS2M_KNOCK_IMPS2_2ND,
+    PS2M_KNOCK_IMEX_1ST,
+    PS2M_KNOCK_IMEX_2ND
+} PS2M_KNOCK_STATE;
+
+/**
+ * The PS/2 auxiliary device instance data.
+ */
+typedef struct PS2M
+{
+    /** Pointer to parent device (keyboard controller). */
+    R3PTRTYPE(void *)   pParent;
+    /** Operational state. */
+    uint8_t             u8State;
+    /** Configured sampling rate. */
+    uint8_t             u8SampleRate;
+    /** Configured resolution. */
+    uint8_t             u8Resolution;
+    /** Currently processed command (if any). */
+    uint8_t             u8CurrCmd;
+    /** Set if the throttle delay is active. */
+    bool                fThrottleActive;
+    /** Operational mode. */
+    PS2M_MODE           enmMode;
+    /** Currently used protocol. */
+    PS2M_PROTO          enmProtocol;
+    /** Currently used protocol. */
+    PS2M_KNOCK_STATE    enmKnockState;
+    /** Buffer holding mouse events to be sent to the host. */
+    AuxEvtQ             evtQ;
+    /** Command response queue (priority). */
+    AuxCmdQ             cmdQ;
+    /** Accumulated horizontal movement. */
+    int32_t             iAccumX;
+    /** Accumulated vertical movement. */
+    int32_t             iAccumY;
+    /** Accumulated Z axis movement. */
+    int32_t             iAccumZ;
+    /** Accumulated button presses. */
+    uint32_t            fAccumB;
+    /** Throttling delay in milliseconds. */
+    unsigned            uThrottleDelay;
+#if HC_ARCH_BITS == 32
+    uint32_t            Alignment0;
+#endif
+
+    /** The device critical section protecting everything - R3 Ptr */
+    R3PTRTYPE(PPDMCRITSECT) pCritSectR3;
+    /** Command delay timer - R3 Ptr. */
+    PTMTIMERR3          pDelayTimerR3;
+    /** Interrupt throttling timer - R3 Ptr. */
+    PTMTIMERR3          pThrottleTimerR3;
+    RTR3PTR             Alignment1;
+
+    /** Command delay timer - RC Ptr. */
+    PTMTIMERRC          pDelayTimerRC;
+    /** Interrupt throttling timer - RC Ptr. */
+    PTMTIMERRC          pThrottleTimerRC;
+
+    /** Command delay timer - R0 Ptr. */
+    PTMTIMERR0          pDelayTimerR0;
+    /** Interrupt throttling timer - R0 Ptr. */
+    PTMTIMERR0          pThrottleTimerR0;
+
+    /**
+     * Mouse port - LUN#1.
+     *
+     * @implements  PDMIBASE
+     * @implements  PDMIMOUSEPORT
+     */
+    struct
+    {
+        /** The base interface for the mouse port. */
+        PDMIBASE                            IBase;
+        /** The keyboard port base interface. */
+        PDMIMOUSEPORT                       IPort;
+
+        /** The base interface of the attached mouse driver. */
+        R3PTRTYPE(PPDMIBASE)                pDrvBase;
+        /** The keyboard interface of the attached mouse driver. */
+        R3PTRTYPE(PPDMIMOUSECONNECTOR)      pDrv;
+    } Mouse;
+} PS2M, *PPS2M;
+
+AssertCompile(PS2M_STRUCT_FILLER >= sizeof(PS2M));
+
+#ifndef VBOX_DEVICE_STRUCT_TESTCASE
+
+/* Key type flags. */
+#define KF_E0        0x01    /* E0 prefix. */
+#define KF_NB        0x02    /* No break code. */
+#define KF_GK        0x04    /* Gray navigation key. */
+#define KF_PS        0x08    /* Print Screen key. */
+#define KF_PB        0x10    /* Pause/Break key. */
+#define KF_NL        0x20    /* Num Lock key. */
+#define KF_NS        0x40    /* NumPad '/' key. */
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+
+
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+
+
+/**
+ * Clear a queue.
+ *
+ * @param   pQ                  Pointer to the queue.
+ */
+static void ps2kClearQueue(GeneriQ *pQ)
+{
+    LogFlowFunc(("Clearing queue %p\n", pQ));
+    pQ->wpos  = pQ->rpos;
+    pQ->cUsed = 0;
+}
+
+
+/**
+ * Add a byte to a queue.
+ *
+ * @param   pQ                  Pointer to the queue.
+ * @param   val                 The byte to store.
+ */
+static void ps2kInsertQueue(GeneriQ *pQ, uint8_t val)
+{
+    /* Check if queue is full. */
+    if (pQ->cUsed >= pQ->cSize)
+    {
+        LogFlowFunc(("queue %p full (%d entries)\n", pQ, pQ->cUsed));
+        return;
+    }
+    /* Insert data and update circular buffer write position. */
+    pQ->abQueue[pQ->wpos] = val;
+    if (++pQ->wpos == pQ->cSize)
+        pQ->wpos = 0;   /* Roll over. */
+    ++pQ->cUsed;
+    LogFlowFunc(("inserted 0x%02X into queue %p\n", val, pQ));
+}
+
+#ifdef IN_RING3
+
+/**
+ * Save a queue state.
+ *
+ * @param   pSSM                SSM handle to write the state to.
+ * @param   pQ                  Pointer to the queue.
+ */
+static void ps2kSaveQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
+{
+    uint32_t    cItems = pQ->cUsed;
+    int         i;
+
+    /* Only save the number of items. Note that the read/write
+     * positions aren't saved as they will be rebuilt on load.
+     */
+    SSMR3PutU32(pSSM, cItems);
+
+    LogFlow(("Storing %d items from queue %p\n", cItems, pQ));
+
+    /* Save queue data - only the bytes actually used (typically zero). */
+    for (i = pQ->rpos; cItems-- > 0; i = (i + 1) % pQ->cSize)
+        SSMR3PutU8(pSSM, pQ->abQueue[i]);
+}
+
+/**
+ * Load a queue state.
+ *
+ * @param   pSSM                SSM handle to read the state from.
+ * @param   pQ                  Pointer to the queue.
+ *
+ * @return  int                 VBox status/error code.
+ */
+static int ps2kLoadQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
+{
+    int         rc;
+
+    /* On load, always put the read pointer at zero. */
+    SSMR3GetU32(pSSM, &pQ->cUsed);
+
+    LogFlow(("Loading %d items to queue %p\n", pQ->cUsed, pQ));
+
+    if (pQ->cUsed > pQ->cSize)
+    {
+        AssertMsgFailed(("Saved size=%u, actual=%u\n", pQ->cUsed, pQ->cSize));
+        return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
+    }
+
+    /* Recalculate queue positions and load data in one go. */
+    pQ->rpos = 0;
+    pQ->wpos = pQ->cUsed;
+    rc = SSMR3GetMem(pSSM, pQ->abQueue, pQ->cUsed);
+
+    return rc;
+}
+
+/* Report a change in status down (or is it up?) the driver chain. */
+static void ps2mSetDriverState(PPS2M pThis, bool fEnabled)
+{
+    PPDMIMOUSECONNECTOR pDrv = pThis->Mouse.pDrv;
+    if (pDrv)
+        pDrv->pfnReportModes(pDrv, fEnabled, false, false);
+}
+
+#endif /* IN_RING3 */
+
+/**
+ * Retrieve a byte from a queue.
+ *
+ * @param   pQ                  Pointer to the queue.
+ * @param   pVal                Pointer to storage for the byte.
+ *
+ * @return  int                 VINF_TRY_AGAIN if queue is empty,
+ *                              VINF_SUCCESS if a byte was read.
+ */
+static int ps2kRemoveQueue(GeneriQ *pQ, uint8_t *pVal)
+{
+    int     rc = VINF_TRY_AGAIN;
+
+    Assert(pVal);
+    if (pQ->cUsed)
+    {
+        *pVal = pQ->abQueue[pQ->rpos];
+        if (++pQ->rpos == pQ->cSize)
+            pQ->rpos = 0;   /* Roll over. */
+        --pQ->cUsed;
+        rc = VINF_SUCCESS;
+        LogFlowFunc(("removed 0x%02X from queue %p\n", *pVal, pQ));
+    } else
+        LogFlowFunc(("queue %p empty\n", pQ));
+    return rc;
+}
+
+static void ps2mSetRate(PPS2M pThis, uint8_t rate)
+{
+    pThis->uThrottleDelay = 1000 / rate;
+    pThis->u8SampleRate = rate;
+    LogFlowFunc(("Sampling rate %u, throttle delay %u ms\n", pThis->u8SampleRate, pThis->uThrottleDelay));
+}
+
+static void ps2mSetDefaults(PPS2M pThis)
+{
+    LogFlowFunc(("Set mouse defaults\n"));
+    /* Standard protocol, reporting disabled, resolution 2, 1:1 scaling. */
+    pThis->enmProtocol  = PS2M_PROTO_PS2STD;
+    pThis->u8State      = 0;
+    pThis->u8Resolution = 2;
+
+    /* Sample rate 100 reports per second. */
+    ps2mSetRate(pThis, 100);
+
+    /* Accumulators and button status bits are cleared. */
+    ps2kClearQueue((GeneriQ *)&pThis->evtQ);
+    //@todo accumulators/current state
+}
+
+/* Handle the sampling rate 'knock' sequence which selects protocol. */
+static void ps2mRateProtocolKnock(PPS2M pThis, uint8_t rate)
+{
+    if (pThis->enmProtocol == PS2M_PROTO_PS2STD)
+    {
+        switch (pThis->enmKnockState) 
+        {
+        case PS2M_KNOCK_INITIAL:
+            if (rate == 200)
+                pThis->enmKnockState = PS2M_KNOCK_IMPS2_1ST;
+            break;
+        case PS2M_KNOCK_IMPS2_1ST:
+            if (rate == 100)
+                pThis->enmKnockState = PS2M_KNOCK_IMPS2_2ND;
+            else
+                pThis->enmKnockState = PS2M_KNOCK_INITIAL;
+            break;
+        case PS2M_KNOCK_IMPS2_2ND:
+            if (rate == 80)
+            {
+                pThis->enmProtocol = PS2M_PROTO_IMPS2;
+                LogRelFlow(("PS2M: Switching mouse to ImPS/2 protocol.\n"));
+            }
+        default:
+            pThis->enmKnockState = PS2M_KNOCK_INITIAL;
+        }
+    } 
+    else if (pThis->enmProtocol == PS2M_PROTO_IMPS2) 
+    {
+        switch (pThis->enmKnockState) 
+        {
+        case PS2M_KNOCK_INITIAL:
+            if (rate == 200)
+                pThis->enmKnockState = PS2M_KNOCK_IMEX_1ST;
+            break;
+        case PS2M_KNOCK_IMEX_1ST:
+            if (rate == 200)
+                pThis->enmKnockState = PS2M_KNOCK_IMEX_2ND;
+            else
+                pThis->enmKnockState = PS2M_KNOCK_INITIAL;
+            break;
+        case PS2M_KNOCK_IMEX_2ND:
+            if (rate == 80)
+            {
+                pThis->enmProtocol = PS2M_PROTO_IMEX;
+                LogRelFlow(("PS2M: Switching mouse to ImEx protocol.\n"));
+            }
+        default:
+            pThis->enmKnockState = PS2M_KNOCK_INITIAL;
+        }
+    }
+}
+
+/**
+ * Receive and process a byte sent by the keyboard controller.
+ *
+ * @param   pThis               The PS/2 auxiliary device instance data.
+ * @param   cmd                 The command (or data) byte.
+ */
+int PS2MByteToAux(PPS2M pThis, uint8_t cmd)
+{
+    uint8_t u8Val;
+    bool    fHandled = true;
+
+    LogFlowFunc(("cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
+//LogRel(("aux: cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
+
+    switch (cmd)
+    {
+        case ACMD_SET_SCALE_11:
+            pThis->u8State &= ~AUX_STATE_SCALING;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_SET_SCALE_21:
+            pThis->u8State |= AUX_STATE_SCALING;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_REQ_STATUS:
+            /* Report current status, sample rate, and resolution. */
+            //@todo: buttons
+            u8Val  = pThis->u8State;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, u8Val);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8Resolution);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8SampleRate);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_SET_STREAM:
+            pThis->u8State &= ~AUX_STATE_REMOTE;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_RESET_WRAP:
+            pThis->enmMode = AUX_MODE_STD;
+            /* NB: Stream mode reporting remains disabled! */
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_SET_WRAP:
+            pThis->enmMode = AUX_MODE_WRAP;
+            pThis->u8State &= ~AUX_STATE_ENABLED;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_SET_REMOTE:
+            pThis->u8State |= AUX_STATE_REMOTE;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_READ_ID:
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->enmProtocol);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_ENABLE:
+            pThis->u8State |= AUX_STATE_ENABLED;
+            //@todo: R3 only!
+#ifdef IN_RING3
+            ps2mSetDriverState(pThis, true);
+#endif
+            ps2kClearQueue((GeneriQ *)&pThis->evtQ);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_DFLT_DISABLE:
+            ps2mSetDefaults(pThis);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_SET_DEFAULT:
+            ps2mSetDefaults(pThis);
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_RESEND:
+            pThis->u8CurrCmd = 0;
+            break;
+        case ACMD_RESET:
+            ps2mSetDefaults(pThis);
+            ///@todo reset more?
+            pThis->u8CurrCmd = cmd;
+            pThis->enmMode   = AUX_MODE_RESET;
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            /* Slightly delay reset completion; it might take hundreds of ms. */
+            TMTimerSetMillies(pThis->CTX_SUFF(pDelayTimer), 1);
+            break;
+        /* The following commands need a parameter. */
+        case ACMD_SET_RES:
+        case ACMD_SET_SAMP_RATE:
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+            pThis->u8CurrCmd = cmd;
+            break;
+        default:
+            /* Sending a command instead of a parameter starts the new command. */
+            switch (pThis->u8CurrCmd)
+            {
+                case ACMD_SET_RES:
+                    //@todo reject unsupported resolutions
+                    pThis->u8Resolution = cmd;
+                    ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+                    pThis->u8CurrCmd = 0;
+                    break;
+                case ACMD_SET_SAMP_RATE:
+                    //@todo reject unsupported rates                    
+                    ps2mSetRate(pThis, cmd);
+                    ps2mRateProtocolKnock(pThis, cmd);
+                    ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
+                    pThis->u8CurrCmd = 0;
+                    break;
+                default:
+                    fHandled = false;
+            }
+            /* Fall through only to handle unrecognized commands. */
+            if (fHandled)
+                break;
+
+        case ACMD_INVALID_1:
+        case ACMD_INVALID_2:
+        case ACMD_INVALID_3:
+        case ACMD_INVALID_4:
+        case ACMD_INVALID_5:
+        case ACMD_INVALID_6:
+        case ACMD_INVALID_7:
+        case ACMD_INVALID_8:
+        case ACMD_INVALID_9:
+        case ACMD_INVALID_10:
+            Log(("Unsupported command 0x%02X!\n", cmd));
+            ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_RESEND);
+            pThis->u8CurrCmd = 0;
+            break;
+    }
+    LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
+//    KBCUpdateInterrupts(pThis->pParent);
+    return VINF_SUCCESS;
+}
+
+/**
+ * Send a byte (keystroke or command response) to the keyboard controller.
+ *
+ * @returns VINF_SUCCESS or VINF_TRY_AGAIN.
+ * @param   pThis               The PS/2 auxiliary device instance data.
+ * @param   pb                  Where to return the byte we've read.
+ * @remarks Caller must have entered the device critical section.
+ */
+int PS2MByteFromAux(PPS2M pThis, uint8_t *pb)
+{
+    int         rc;
+
+    AssertPtr(pb);
+
+    /* Anything in the command queue has priority over data
+     * in the event queue. Additionally, keystrokes are //@todo: true?
+     * blocked if a command is currently in progress, even if
+     * the command queue is empty.
+     */
+    //@todo: Probably should flush/not fill queue if stream mode reporting disabled?!
+    rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
+    if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED))
+        rc = ps2kRemoveQueue((GeneriQ *)&pThis->evtQ, pb);
+
+    LogFlowFunc(("mouse sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
+//if (rc == VINF_SUCCESS) LogRel(("aux: sends 0x%02X\n", *pb));
+
+    return rc;
+}
+
+#ifdef IN_RING3
+
+/* Three-button event mask. */
+#define PS2M_STD_BTN_MASK   (RT_BIT(0) | RT_BIT(1) | RT_BIT(2))
+
+/* Report accumulated movement and button presses, then clear the accumulators. */
+static void ps2mReportAccumulatedEvents(PPS2M pThis)
+{
+    uint8_t     val;
+    int8_t      dX, dY, dZ;
+
+    /* Clamp the accumulated delta values to the allowed range. */
+    dX = RT_MIN(RT_MAX(pThis->iAccumX, -256), 255);
+    dY = RT_MIN(RT_MAX(pThis->iAccumY, -256), 255);
+    dZ = RT_MIN(RT_MAX(pThis->iAccumZ, -8), 7);
+
+    /* Start with the sync bit and buttons 1-3. */
+    val = RT_BIT(3) | (pThis->fAccumB & PS2M_STD_BTN_MASK);
+    /* Set the X/Y sign bits. */
+    if (dX < 0)
+        val |= RT_BIT(4);
+    if (dY < 0)
+        val |= RT_BIT(5);
+
+    /* Send the standard 3-byte packet (always the same). */
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, val);
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dX);
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dY);
+
+    /* Add fourth byte if extended protocol is in use. */
+    if (pThis->enmProtocol > PS2M_PROTO_PS2STD)
+    {
+        if (pThis->enmProtocol == PS2M_PROTO_IMPS2)
+            ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dZ);
+        else
+        {
+            Assert(pThis->enmProtocol == PS2M_PROTO_IMEX);
+            /* Z value uses 4 bits; buttons 4/5 in bits 4 and 5. */
+            val  = dZ & 0x0f;
+            val |= (pThis->fAccumB << 1) & (RT_BIT(4) | RT_BIT(5));
+            ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dZ);
+        }
+    }
+
+    /* Clear the accumulators. */
+    pThis->iAccumX = pThis->iAccumY = pThis->iAccumZ = pThis->fAccumB = 0;
+
+    /* Poke the KBC to update its state. */
+    KBCUpdateInterrupts(pThis->pParent);
+}
+
+/* Event rate throttling timer to emulate the auxiliary device sampling rate.
+ */
+static DECLCALLBACK(void) ps2mThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+{
+    PPS2M       pThis = (PS2M *)pvUser; NOREF(pDevIns);
+    uint32_t    uHaveEvents;
+
+    /* Grab the lock to avoid races with PutEvent(). */
+    int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
+    AssertReleaseRC(rc);
+
+#if 0
+    /* If the input queue is not empty, restart the timer. */
+#else
+    /* If more movement is accumulated, report it and restart the timer. */
+    uHaveEvents = pThis->iAccumX | pThis->iAccumY | pThis->iAccumZ | pThis->fAccumB;
+    LogFlowFunc(("Have%s events\n", uHaveEvents ? "" : " no"));
+
+    if (uHaveEvents)
+#endif
+    {
+        ps2mReportAccumulatedEvents(pThis);
+        TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);
+    }
+    else
+        pThis->fThrottleActive = false;
+
+    PDMCritSectLeave(pThis->pCritSectR3);
+}
+
+/* The auxiliary device is specified to take up to about 500 milliseconds. We need
+ * to delay sending the result to the host for at least a tiny little while.
+ */
+static DECLCALLBACK(void) ps2mDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+{
+    PPS2M pThis = (PS2M *)pvUser; NOREF(pDevIns);
+
+    LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
+
+    Assert(pThis->u8CurrCmd == ACMD_RESET);
+    ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_BAT_OK);
+    ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, 0);
+    pThis->enmMode   = AUX_MODE_STD;
+    pThis->u8CurrCmd = 0;
+
+    ///@todo Might want a PS2MCompleteCommand() to push last response, clear command, and kick the KBC...
+    /* Give the KBC a kick. */
+    KBCUpdateInterrupts(pThis->pParent);
+
+    //@todo: move to its proper home!
+    ps2mSetDriverState(pThis, true);
+}
+
+
+/**
+ * Debug device info handler. Prints basic auxiliary device state.
+ *
+ * @param   pDevIns     Device instance which registered the info.
+ * @param   pHlp        Callback functions for doing output.
+ * @param   pszArgs     Argument string. Optional and specific to the handler.
+ */
+static DECLCALLBACK(void) ps2mInfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+{
+    static const char   *pcszModes[] = { "normal", "reset", "wrap" };
+    static const char   *pcszProtocols[] = { "PS/2", NULL, NULL, "ImPS/2", "ImEx" };
+    PPS2M   pThis = KBDGetPS2MFromDevIns(pDevIns);
+    NOREF(pszArgs);
+
+    Assert(pThis->enmMode <= RT_ELEMENTS(pcszModes));
+    Assert(pThis->enmProtocol <= RT_ELEMENTS(pcszProtocols));
+    pHlp->pfnPrintf(pHlp, "PS/2 mouse state: %s, %s mode, reporting %s\n",
+                    pcszModes[pThis->enmMode],
+                    pThis->u8State & AUX_STATE_REMOTE  ? "remote"  : "stream",
+                    pThis->u8State & AUX_STATE_ENABLED ? "enabled" : "disabled");
+    pHlp->pfnPrintf(pHlp, "Protocol: %s, scaling %u:1\n",
+                    pcszProtocols[pThis->enmProtocol], pThis->u8State & AUX_STATE_SCALING ? 2 : 1);
+    pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
+    pHlp->pfnPrintf(pHlp, "Sampling rate %u reports/sec, resolution %u counts/mm\n",
+                    pThis->u8SampleRate, 1 << pThis->u8Resolution);
+    pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
+                    pThis->cmdQ.cUsed, pThis->cmdQ.cSize);
+    pHlp->pfnPrintf(pHlp, "Event queue  : %d items (%d max)\n",
+                    pThis->evtQ.cUsed, pThis->evtQ.cSize);
+}
+
+/* -=-=-=-=-=- Mouse: IBase  -=-=-=-=-=- */
+
+/**
+ * @interface_method_impl{PDMIBASE,pfnQueryInterface}
+ */
+static DECLCALLBACK(void *) ps2mQueryInterface(PPDMIBASE pInterface, const char *pszIID)
+{
+    PPS2M pThis = RT_FROM_MEMBER(pInterface, PS2M, Mouse.IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Mouse.IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSEPORT, &pThis->Mouse.IPort);
+    return NULL;
+}
+
+
+/* -=-=-=-=-=- Mouse: IMousePort  -=-=-=-=-=- */
+
+/**
+ * Mouse event handler.
+ *
+ * @returns VBox status code.
+ * @param   pThis           The PS/2 auxiliary device instance data.
+ * @param   dx              X direction movement delta.
+ * @param   dy              Y direction movement delta.
+ * @param   dz              Z (vertical scroll) movement delta.
+ * @param   dw              W (horizontal scroll) movement delta.
+ * @param   fButtons        Depressed button mask.
+ */
+static int ps2mPutEventWorker(PPS2M pThis, int32_t dx, int32_t dy,
+                              int32_t dz, int32_t dw, uint32_t fButtons)
+{
+    int             rc = VINF_SUCCESS;
+
+    /* Update internal accumulators and button state. */
+    pThis->iAccumX += dx;
+    pThis->iAccumY += dy;
+    pThis->iAccumZ += dz;
+    pThis->fAccumB |= fButtons & PS2M_STD_BTN_MASK; //@todo: accumulate based on current protocol?
+
+#if 1
+    /* Report the event and the throttle timer unless it's already running. */
+    if (!pThis->fThrottleActive)
+    {
+        ps2mReportAccumulatedEvents(pThis);
+        pThis->fThrottleActive = true;
+        TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);
+    }
+#else
+    /* Clamp the delta values to the allowed range. */
+    dx = RT_MIN(RT_MAX(dx, -256), 255);
+    dy = RT_MIN(RT_MAX(dy, -256), 255);
+
+    /* Start with the sync bit. */
+    val  = RT_BIT(3);
+    /* Add buttons 1-3. */
+    val |= fButtons & PS2M_STD_BTN_MASK;
+    /* Set the X/Y sign bits. */
+    if (dx < 0)
+        val |= RT_BIT(4);
+    if (dy < 0)
+        val |= RT_BIT(5);
+
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, val);
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dx);
+    ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dy);
+    if (pThis->enmProtocol > PS2M_PROTO_PS2STD)
+    {
+        ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dz);
+    }
+#endif
+
+    return rc;
+}
+
+/* -=-=-=-=-=- Mouse: IMousePort  -=-=-=-=-=- */
+
+/**
+ * @interface_method_impl{PDMIMOUSEPORT, pfnPutEvent}
+ */
+static DECLCALLBACK(int) ps2mPutEvent(PPDMIMOUSEPORT pInterface, int32_t dx, int32_t dy,
+                                      int32_t dz, int32_t dw, uint32_t fButtons)
+{
+    PPS2M       pThis = RT_FROM_MEMBER(pInterface, PS2M, Mouse.IPort);
+    int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
+    AssertReleaseRC(rc);
+
+    LogFlowFunc(("dX=%d dY=%d dZ=%d dW=%d buttons=%02X\n", dx, dy, dz, dw, fButtons));
+    /* NB: The PS/2 Y axis direction is inverted relative to ours. */
+    ps2mPutEventWorker(pThis, dx, -dy, dz, dw, fButtons);
+
+    PDMCritSectLeave(pThis->pCritSectR3);
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{PDMIMOUSEPORT, pfnPutEventAbs}
+ */
+static DECLCALLBACK(int) ps2mPutEventAbs(PPDMIMOUSEPORT pInterface, uint32_t x, uint32_t y,
+                                         int32_t dz, int32_t dw, uint32_t fButtons)
+{
+    AssertFailedReturn(VERR_NOT_SUPPORTED);
+    NOREF(pInterface); NOREF(x); NOREF(y); NOREF(dz); NOREF(dw); NOREF(fButtons);
+}
+
+/**
+ * @interface_method_impl{PDMIMOUSEPORT, pfnPutEventMultiTouch}
+ */
+static DECLCALLBACK(int) ps2mPutEventMT(PPDMIMOUSEPORT pInterface, uint8_t cContacts,
+                                        const uint64_t *pau64Contacts, uint32_t u32ScanTime)
+{
+    AssertFailedReturn(VERR_NOT_SUPPORTED);
+    NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
+}
+
+
+
+/**
+ * Attach command.
+ *
+ * This is called to let the device attach to a driver for a
+ * specified LUN.
+ *
+ * This is like plugging in the mouse after turning on the
+ * system.
+ *
+ * @returns VBox status code.
+ * @param   pThis       The PS/2 auxiliary device instance data.
+ * @param   pDevIns     The device instance.
+ * @param   iLUN        The logical unit which is being detached.
+ * @param   fFlags      Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
+ */
+int PS2MAttach(PPS2M pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
+{
+    int         rc;
+
+    /* The LUN must be 1, i.e. mouse. */
+    Assert(iLUN == 1);
+    AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
+                    ("PS/2 mouse does not support hotplugging\n"),
+                    VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("iLUN=%d\n", iLUN));
+
+    rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Mouse.IBase, &pThis->Mouse.pDrvBase, "Mouse Port");
+    if (RT_SUCCESS(rc))
+    {
+        pThis->Mouse.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Mouse.pDrvBase, PDMIMOUSECONNECTOR);
+        if (!pThis->Mouse.pDrv)
+        {
+            AssertLogRelMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Rrc\n", rc));
+            rc = VERR_PDM_MISSING_INTERFACE;
+        }
+    }
+    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
+    {
+        Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szName, pDevIns->iInstance));
+        rc = VINF_SUCCESS;
+    }
+    else
+        AssertLogRelMsgFailed(("Failed to attach LUN #1! rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+void PS2MSaveState(PPS2M pThis, PSSMHANDLE pSSM)
+{
+    uint32_t    cPressed = 0;
+
+    LogFlowFunc(("Saving PS2M state\n"));
+
+    /* Save the core auxiliary device state. */
+    SSMR3PutU8(pSSM, pThis->u8State);
+    SSMR3PutU8(pSSM, pThis->u8SampleRate);
+    SSMR3PutU8(pSSM, pThis->u8Resolution);
+    SSMR3PutU8(pSSM, pThis->u8CurrCmd);
+    SSMR3PutU8(pSSM, pThis->enmMode);
+    SSMR3PutU8(pSSM, pThis->enmProtocol);
+    SSMR3PutU8(pSSM, pThis->enmKnockState);
+
+    /* Save the command and event queues. */
+    ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
+    ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->evtQ);
+
+    /* Save the command delay timer. Note that the rate throttling
+     * timer is *not* saved.
+     */
+    TMR3TimerSave(pThis->CTX_SUFF(pDelayTimer), pSSM);
+}
+
+int PS2MLoadState(PPS2M pThis, PSSMHANDLE pSSM, uint32_t uVersion)
+{
+    uint8_t     u8;
+    int         rc;
+
+    NOREF(uVersion);
+    LogFlowFunc(("Loading PS2M state version %u\n", uVersion));
+
+    /* Load the basic auxiliary device state. */
+    SSMR3GetU8(pSSM, &pThis->u8State);
+    SSMR3GetU8(pSSM, &pThis->u8SampleRate);
+    SSMR3GetU8(pSSM, &pThis->u8Resolution);
+    SSMR3GetU8(pSSM, &pThis->u8CurrCmd);
+    SSMR3GetU8(pSSM, &u8);
+    pThis->enmMode       = (PS2M_MODE)u8;
+    SSMR3GetU8(pSSM, &u8);
+    pThis->enmProtocol   = (PS2M_PROTO)u8;
+    SSMR3GetU8(pSSM, &u8);
+    pThis->enmKnockState = (PS2M_KNOCK_STATE)u8;
+
+    /* Load the command and event queues. */
+    rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
+    AssertRCReturn(rc, rc);
+    rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->evtQ);
+    AssertRCReturn(rc, rc);
+
+    /* Load the command delay timer, just in case. */
+    rc = TMR3TimerLoad(pThis->CTX_SUFF(pDelayTimer), pSSM);
+    AssertRCReturn(rc, rc);
+
+    /* Recalculate the throttling delay. */
+    ps2mSetRate(pThis, pThis->u8SampleRate);
+
+    //@todo: Is this the right place/logic?
+    ps2mSetDriverState(pThis, !!(pThis->u8State & AUX_STATE_ENABLED));
+
+    return rc;
+}
+
+void PS2MReset(PPS2M pThis)
+{
+    LogFlowFunc(("Resetting PS2M\n"));
+
+    pThis->u8CurrCmd         = 0;
+
+    /* Clear the queues. */
+    ps2kClearQueue((GeneriQ *)&pThis->cmdQ);
+    ps2mSetDefaults(pThis);     /* Also clears event queue. */
+
+    /* Activate the PS/2 mouse by default. */
+//    if (pThis->Mouse.pDrv)
+//        pThis->Mouse.pDrv->pfnSetActive(pThis->Mouse.pDrv, true);
+}
+
+void PS2MRelocate(PPS2M pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns)
+{
+    LogFlowFunc(("Relocating PS2M\n"));
+    pThis->pDelayTimerRC    = TMTimerRCPtr(pThis->pDelayTimerR3);
+    pThis->pThrottleTimerRC = TMTimerRCPtr(pThis->pThrottleTimerR3);
+    NOREF(offDelta);
+}
+
+int PS2MConstruct(PPS2M pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance)
+{
+    int     rc;
+
+    LogFlowFunc(("iInstance=%d\n", iInstance));
+
+    pThis->pParent = pParent;
+
+    /* Initialize the queues. */
+    pThis->evtQ.cSize = AUX_EVT_QUEUE_SIZE;
+    pThis->cmdQ.cSize = AUX_CMD_QUEUE_SIZE;
+
+    pThis->Mouse.IBase.pfnQueryInterface     = ps2mQueryInterface;
+    pThis->Mouse.IPort.pfnPutEvent           = ps2mPutEvent;
+    pThis->Mouse.IPort.pfnPutEventAbs        = ps2mPutEventAbs;
+    pThis->Mouse.IPort.pfnPutEventMultiTouch = ps2mPutEventMT;
+
+    /*
+     * Initialize the critical section pointer(s).
+     */
+    pThis->pCritSectR3 = pDevIns->pCritSectRoR3;
+
+    /*
+     * Create the input rate throttling timer. Does not use virtual time!
+     */
+    PTMTIMER pTimer;
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2mThrottleTimer, pThis,
+                                TMTIMER_FLAGS_NO_CRIT_SECT, "PS2M Throttle Timer", &pTimer);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    pThis->pThrottleTimerR3 = pTimer;
+    pThis->pThrottleTimerR0 = TMTimerR0Ptr(pTimer);
+    pThis->pThrottleTimerRC = TMTimerRCPtr(pTimer);
+
+    /*
+     * Create the command delay timer.
+     */
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2mDelayTimer, pThis,
+                                TMTIMER_FLAGS_NO_CRIT_SECT, "PS2M Delay Timer", &pTimer);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    pThis->pDelayTimerR3 = pTimer;
+    pThis->pDelayTimerR0 = TMTimerR0Ptr(pTimer);
+    pThis->pDelayTimerRC = TMTimerRCPtr(pTimer);
+
+    /*
+     * Register debugger info callbacks.
+     */
+    PDMDevHlpDBGFInfoRegister(pDevIns, "ps2m", "Display PS/2 mouse state.", ps2mInfoState);
+
+    //@todo: Where should we do this?
+    ps2mSetDriverState(pThis, true);
+    pThis->u8State = 0;
+    pThis->enmMode = AUX_MODE_STD;
+
+    return rc;
+}
+
+#endif
+
+#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Index: trunk/src/VBox/Devices/Makefile.kmk
===================================================================
--- trunk/src/VBox/Devices/Makefile.kmk	(revision 48195)
+++ trunk/src/VBox/Devices/Makefile.kmk	(revision 48214)
@@ -129,4 +129,5 @@
  	Input/DevPS2.cpp \
  	Input/PS2K.cpp \
+ 	Input/PS2M.cpp \
  	Input/UsbKbd.cpp \
  	Input/UsbMouse.cpp \
@@ -453,4 +454,11 @@
 
 
+ # --- Input bits. ---
+
+ ifdef VBOX_WITH_NEW_PS2M
+  VBoxDD_DEFS           += VBOX_WITH_NEW_PS2M
+ endif
+
+
  # --- Audio bits. ---
 
@@ -757,4 +765,5 @@
   	Input/DevPS2.cpp \
  	Input/PS2K.cpp \
+ 	Input/PS2M.cpp \
   	PC/DevACPI.cpp \
   	PC/DevPit-i8254.cpp \
@@ -836,4 +845,8 @@
   VBoxDDGC_SOURCES      += \
   	Storage/DevLsiLogicSCSI.cpp
+  endif
+
+  ifdef VBOX_WITH_NEW_PS2M
+  VBoxDDGC_DEFS         += VBOX_WITH_NEW_PS2M
   endif
 
@@ -894,4 +907,5 @@
  	Input/DevPS2.cpp \
  	Input/PS2K.cpp \
+ 	Input/PS2M.cpp \
  	PC/DevACPI.cpp \
  	PC/DevPit-i8254.cpp \
@@ -984,4 +998,8 @@
  VBoxDDR0_SOURCES       += \
  	Storage/DevLsiLogicSCSI.cpp
+ endif
+
+ ifdef VBOX_WITH_NEW_PS2M
+  VBoxDDR0_DEFS         += VBOX_WITH_NEW_PS2M
  endif
 
Index: trunk/src/VBox/Devices/testcase/Makefile.kmk
===================================================================
--- trunk/src/VBox/Devices/testcase/Makefile.kmk	(revision 48195)
+++ trunk/src/VBox/Devices/testcase/Makefile.kmk	(revision 48214)
@@ -36,4 +36,5 @@
 	$(if $(VBOX_WITH_BUSLOGIC),VBOX_WITH_BUSLOGIC,) \
 	$(if $(VBOX_WITH_LSILOGIC),VBOX_WITH_LSILOGIC,) \
+	$(if $(VBOX_WITH_NEW_PS2M),VBOX_WITH_NEW_PS2M,) \
 	$(if $(VBOX_WITH_HGSMI),VBOX_WITH_HGSMI,) \
 	$(if $(VBOX_WITH_CRHGSMI),VBOX_WITH_CRHGSMI,) \
Index: trunk/src/VBox/Devices/testcase/tstDeviceStructSize.cpp
===================================================================
--- trunk/src/VBox/Devices/testcase/tstDeviceStructSize.cpp	(revision 48195)
+++ trunk/src/VBox/Devices/testcase/tstDeviceStructSize.cpp	(revision 48214)
@@ -37,4 +37,6 @@
 #undef LOG_GROUP
 #include "../Input/PS2K.cpp"
+#undef LOG_GROUP
+#include "../Input/PS2M.cpp"
 #ifdef VBOX_WITH_E1000
 # undef LOG_GROUP
Index: trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp
===================================================================
--- trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp	(revision 48195)
+++ trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp	(revision 48214)
@@ -46,4 +46,6 @@
 #undef LOG_GROUP
 #include "../Input/PS2K.cpp"
+#undef LOG_GROUP
+#include "../Input/PS2M.cpp"
 #undef LOG_GROUP
 #include "../Network/DevPCNet.cpp"
@@ -362,4 +364,5 @@
 
     /* Input/pckbd.c */
+#ifndef VBOX_WITH_NEW_PS2M
     GEN_CHECK_SIZE(MouseCmdQueue);
     GEN_CHECK_OFF(MouseCmdQueue, data);
@@ -372,10 +375,12 @@
     GEN_CHECK_OFF(MouseEventQueue, wptr);
     GEN_CHECK_OFF(MouseEventQueue, count);
+#endif
     GEN_CHECK_SIZE(KBDState);
-    GEN_CHECK_OFF(KBDState, mouse_command_queue);
-    GEN_CHECK_OFF(KBDState, mouse_event_queue);
     GEN_CHECK_OFF(KBDState, write_cmd);
     GEN_CHECK_OFF(KBDState, status);
     GEN_CHECK_OFF(KBDState, mode);
+#ifndef VBOX_WITH_NEW_PS2M
+    GEN_CHECK_OFF(KBDState, mouse_command_queue);
+    GEN_CHECK_OFF(KBDState, mouse_event_queue);
     GEN_CHECK_OFF(KBDState, mouse_write_cmd);
     GEN_CHECK_OFF(KBDState, mouse_status);
@@ -390,4 +395,5 @@
     GEN_CHECK_OFF(KBDState, mouse_dw);
     GEN_CHECK_OFF(KBDState, mouse_buttons);
+#endif
     GEN_CHECK_OFF(KBDState, pDevInsR3);
     GEN_CHECK_OFF(KBDState, pDevInsR0);
@@ -400,4 +406,6 @@
     GEN_CHECK_OFF(KbdCmdQ, abQueue);
     GEN_CHECK_SIZE(KbdCmdQ);
+    /* Input/PS2K.c */
+    GEN_CHECK_SIZE(PS2K);
     GEN_CHECK_OFF(PS2K, fScanning);
     GEN_CHECK_OFF(PS2K, fNumLockOn);
@@ -419,8 +427,35 @@
     GEN_CHECK_OFF(PS2K, Keyboard.pDrvBase);
     GEN_CHECK_OFF(PS2K, Keyboard.pDrv);
+#ifdef VBOX_WITH_NEW_PS2M
+    /* Input/PS2M.c */
+    GEN_CHECK_SIZE(PS2M);
+    GEN_CHECK_OFF(PS2M, u8State);
+    GEN_CHECK_OFF(PS2M, u8SampleRate);
+    GEN_CHECK_OFF(PS2M, u8CurrCmd);
+    GEN_CHECK_OFF(PS2M, fThrottleActive);
+    GEN_CHECK_OFF(PS2M, enmMode);
+    GEN_CHECK_OFF(PS2M, enmKnockState);
+    GEN_CHECK_OFF(PS2M, iAccumX);
+    GEN_CHECK_OFF(PS2M, fAccumB);
+    GEN_CHECK_OFF(PS2M, uThrottleDelay);
+    GEN_CHECK_OFF(PS2M, evtQ);
+    GEN_CHECK_OFF(PS2M, cmdQ);
+    GEN_CHECK_OFF(PS2M, pDelayTimerRC);
+    GEN_CHECK_OFF(PS2M, pDelayTimerR3);
+    GEN_CHECK_OFF(PS2M, pDelayTimerR0);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerRC);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerR3);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerR0);
+    GEN_CHECK_OFF(PS2M, pCritSectR3);
+    GEN_CHECK_OFF(PS2M, Mouse.IBase);
+    GEN_CHECK_OFF(PS2M, Mouse.IPort);
+    GEN_CHECK_OFF(PS2M, Mouse.pDrvBase);
+    GEN_CHECK_OFF(PS2M, Mouse.pDrv);
+#else
     GEN_CHECK_OFF(KBDState, Mouse.IBase);
     GEN_CHECK_OFF(KBDState, Mouse.IPort);
     GEN_CHECK_OFF(KBDState, Mouse.pDrvBase);
     GEN_CHECK_OFF(KBDState, Mouse.pDrv);
+#endif
 
     /* Network/DevPCNet.cpp */
