diff --git a/mi/midispcur.c b/mi/midispcur.c
index d7a8964dc..16ece10e6 100644
--- a/mi/midispcur.c
+++ b/mi/midispcur.c
@@ -85,7 +85,7 @@ typedef struct {
 #define MIDCBUFFER(dev) \
  ((DevHasCursor(dev)) ? \
   (miDCBufferPtr)dev->devPrivates[miDCSpriteIndex].ptr :\
-  (miDCBufferPtr)inputInfo.pointer->devPrivates[miDCSpriteIndex].ptr)
+  (miDCBufferPtr)dev->u.master->devPrivates[miDCSpriteIndex].ptr)
 
 /* 
  * The core pointer buffer will point to the index of the virtual core pointer
diff --git a/mi/mipointer.c b/mi/mipointer.c
index eabc43563..0db4d2c56 100644
--- a/mi/mipointer.c
+++ b/mi/mipointer.c
@@ -59,7 +59,7 @@ static int miPointerPrivatesIndex = 0;
 #define MIPOINTER(dev) \
     ((DevHasCursor((dev))) ? \
         (miPointerPtr) dev->devPrivates[miPointerPrivatesIndex].ptr : \
-        (miPointerPtr) inputInfo.pointer->devPrivates[miPointerPrivatesIndex].ptr)
+        (miPointerPtr) dev->u.master->devPrivates[miPointerPrivatesIndex].ptr)
 
 static Bool miPointerRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, 
                                    CursorPtr pCursor);
@@ -210,7 +210,12 @@ miPointerDisplayCursor (pDev, pScreen, pCursor)
     ScreenPtr 	 pScreen;
     CursorPtr	 pCursor;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return FALSE;
+
+    pPointer = MIPOINTER(pDev);
 
     pPointer->pCursor = pCursor;
     pPointer->pScreen = pScreen;
@@ -233,7 +238,12 @@ miPointerConstrainCursor (pDev, pScreen, pBox)
     ScreenPtr	pScreen;
     BoxPtr	pBox;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
+    
+    pPointer = MIPOINTER(pDev);
 
     pPointer->limits = *pBox;
     pPointer->confined = PointerConfinedToScreen(pDev);
@@ -347,7 +357,11 @@ miPointerWarpCursor (pDev, pScreen, x, y)
     ScreenPtr	 pScreen;
     int	   	 x, y;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
+    pPointer = MIPOINTER(pDev);
     SetupScreen (pScreen);
 
     if (pPointer->pScreen != pScreen)
@@ -399,7 +413,7 @@ miPointerUpdateSprite (DeviceIntPtr pDev)
     int			x, y, devx, devy;
     miPointerPtr        pPointer;
 
-    if (!pDev || !pDev->coreEvents)
+    if (!pDev || !pDev->coreEvents || (!pDev->isMaster && !pDev->u.master))
         return;
 
     pPointer = MIPOINTER(pDev);
@@ -488,7 +502,12 @@ miPointerSetScreen(DeviceIntPtr pDev, int screen_no, int x, int y)
 {
 	miPointerScreenPtr pScreenPriv;
 	ScreenPtr pScreen;
-        miPointerPtr pPointer = MIPOINTER(pDev);
+        miPointerPtr pPointer; 
+        
+        if (!pDev->isMaster && !pDev->u.master)
+            return;
+
+        pPointer = MIPOINTER(pDev);
 
 	pScreen = screenInfo.screens[screen_no];
 	pScreenPriv = GetScreenPrivate (pScreen);
@@ -508,8 +527,10 @@ miPointerCurrentScreen ()
 _X_EXPORT ScreenPtr
 miPointerGetScreen(DeviceIntPtr pDev)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
-    return pPointer->pScreen;
+    if (!pDev->isMaster && !pDev->u.master)
+        return NULL;
+
+    return MIPOINTER(pDev)->pScreen;
 }
 
 /* Move the pointer to x, y on the current screen, update the sprite, and
@@ -526,9 +547,13 @@ static void
 miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y,
                      unsigned long time)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
     SetupScreen(pScreen);
 
+    if (!pDev->isMaster && !pDev->u.master) 
+        return;
+
+    pPointer = MIPOINTER(pDev);
 
     if (pDev && pDev->coreEvents 
         && !pScreenPriv->waitForUpdate && pScreen == pPointer->pSpriteScreen)
@@ -551,8 +576,12 @@ miPointerSetPosition(DeviceIntPtr pDev, int *x, int *y, unsigned long time)
     ScreenPtr		pScreen;
     ScreenPtr		newScreen;
 
-    miPointerPtr        pPointer = MIPOINTER(pDev);
+    miPointerPtr        pPointer; 
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
 
+    pPointer = MIPOINTER(pDev);
     pScreen = pPointer->pScreen;
     if (!pScreen)
 	return;	    /* called before ready */
@@ -605,9 +634,14 @@ miPointerPosition (int *x, int *y)
 _X_EXPORT void
 miPointerGetPosition(DeviceIntPtr pDev, int *x, int *y)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
-    *x = pPointer->x;
-    *y = pPointer->y;
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miPointerGetPosition called for floating device.\n");
+        return;
+    }
+
+    *x = MIPOINTER(pDev)->x;
+    *y = MIPOINTER(pDev)->y;
 }
 
 void
diff --git a/mi/misprite.c b/mi/misprite.c
index 6e4215270..6aad36cfb 100644
--- a/mi/misprite.c
+++ b/mi/misprite.c
@@ -77,7 +77,7 @@ static int miSpriteDevPrivatesIndex;
 #define MISPRITE(dev) \
     ((DevHasCursor(dev)) ? \
        (miCursorInfoPtr) dev->devPrivates[miSpriteDevPrivatesIndex].ptr : \
-       (miCursorInfoPtr) inputInfo.pointer->devPrivates[miSpriteDevPrivatesIndex].ptr)
+       (miCursorInfoPtr) dev->u.master->devPrivates[miSpriteDevPrivatesIndex].ptr)
 
 
 /*
@@ -759,6 +759,12 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
     miCursorInfoPtr pCursorInfo;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
+
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRealizeCursor called for floating device.\n");
+        return FALSE;
+    }
     pCursorInfo = MISPRITE(pDev);
 
     if (pCursor == pCursorInfo->pCursor)
@@ -790,7 +796,14 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
     miSpriteScreenPtr	pScreenPriv;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
-    miCursorInfoPtr pPointer = MISPRITE(pDev);
+    miCursorInfoPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteSetCursor called for floating device.\n");
+        return;
+    }
+    pPointer = MISPRITE(pDev);
 
     if (!pCursor)
     {
@@ -905,6 +918,11 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
     CursorPtr pCursor;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteMoveCursor called for floating device.\n");
+        return;
+    }
     pCursor = MISPRITE(pDev)->pCursor;
 
     miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
@@ -972,6 +990,11 @@ miSpriteUndisplayCursor(pDev, pScreen)
     DeviceIntPtr pDev;
     ScreenPtr    pScreen;
 {
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteUndisplayCursor called for floating device.\n");
+        return;
+    }
     if (MISPRITE(pDev)->isUp)
         miSpriteRemoveCursor(pDev, pScreen);
 }
@@ -989,6 +1012,11 @@ miSpriteRemoveCursor (pDev, pScreen)
     miCursorInfoPtr     pCursorInfo;
 
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRemoveCursor called for floating device.\n");
+        return;
+    }
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);
@@ -1026,6 +1054,11 @@ miSpriteSaveUnderCursor(pDev, pScreen)
     CursorPtr		pCursor;
     miCursorInfoPtr     pCursorInfo;
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteSaveUnderCursor called for floating device.\n");
+        return;
+    }
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);
@@ -1065,6 +1098,12 @@ miSpriteRestoreCursor (pDev, pScreen)
     int			x, y;
     CursorPtr		pCursor;
     miCursorInfoPtr     pCursorInfo;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRestoreCursor called for floating device.\n");
+        return;
+    }
 
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
@@ -1106,6 +1145,11 @@ miSpriteComputeSaved (pDev, pScreen)
     CursorPtr	    pCursor;
     miCursorInfoPtr pCursorInfo;
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteComputeSaved called for floating device.\n");
+        return;
+    }
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);