libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

10 files changed, 2000 insertions, 1934 deletions

diff --git a/xorg-server/hw/xfree86/ramdac/BT.c b/xorg-server/hw/xfree86/ramdac/BT.c
index 5aa27a1f8..533344513 100644
--- a/xorg-server/hw/xfree86/ramdac/BT.c
+++ b/xorg-server/hw/xfree86/ramdac/BT.c
@@ -37,36 +37,37 @@
 
 void
 BTramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
-				    RamDacRegRecPtr ramdacReg)
+                RamDacRegRecPtr ramdacReg)
 {
-	int i;
-
-	/* Here we pass a short, so that we can evaluate a mask too */
-	/* So that the mask is the high byte and the data the low byte */
-	/* Just the command/status registers */
-	for (i=0x06;i<0x0A;i++) 
-	    (*ramdacPtr->WriteDAC)
-	        (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8, 
-						ramdacReg->DacRegs[i]);
+    int i;
+
+    /* Here we pass a short, so that we can evaluate a mask too */
+    /* So that the mask is the high byte and the data the low byte */
+    /* Just the command/status registers */
+    for (i = 0x06; i < 0x0A; i++)
+        (*ramdacPtr->WriteDAC)
+            (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8,
+             ramdacReg->DacRegs[i]);
 }
 
 void
-BTramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 
-				 RamDacRegRecPtr ramdacReg)
+BTramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
+             RamDacRegRecPtr ramdacReg)
 {
-	int i;
-	
-	(*ramdacPtr->ReadAddress)(pScrn, 0); /* Start at index 0 */
-	for (i=0;i<768;i++)
-	    ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);
-
-	/* Just the command/status registers */
-	for (i=0x06;i<0x0A;i++)
-	    ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC)(pScrn, i);
+    int i;
+
+    (*ramdacPtr->ReadAddress) (pScrn, 0);       /* Start at index 0 */
+    for (i = 0; i < 768; i++)
+        ramdacReg->DAC[i] = (*ramdacPtr->ReadData) (pScrn);
+
+    /* Just the command/status registers */
+    for (i = 0x06; i < 0x0A; i++)
+        ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC) (pScrn, i);
 }
 
 RamDacHelperRecPtr
-BTramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs/*, RamDacRecPtr ramdacPtr*/)
+BTramdacProbe(ScrnInfoPtr pScrn,
+              RamDacSupportedInfoRecPtr ramdacs /*, RamDacRecPtr ramdacPtr */ )
 {
     RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
     Bool RamDacIsSupported = FALSE;
@@ -75,65 +76,66 @@ BTramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs/*, RamDacRecP
     int i, status, cmd0;
 
     /* Save COMMAND Register 0 */
-    cmd0 = (*ramdacPtr->ReadDAC)(pScrn, BT_COMMAND_REG_0);
+    cmd0 = (*ramdacPtr->ReadDAC) (pScrn, BT_COMMAND_REG_0);
     /* Ensure were going to access the STATUS Register on next read */
-    (*ramdacPtr->WriteDAC)(pScrn, BT_COMMAND_REG_0, 0x7F, 0x00);
+    (*ramdacPtr->WriteDAC) (pScrn, BT_COMMAND_REG_0, 0x7F, 0x00);
 
-    status = (*ramdacPtr->ReadDAC)(pScrn, BT_STATUS_REG);
+    status = (*ramdacPtr->ReadDAC) (pScrn, BT_STATUS_REG);
     switch (status) {
-	case 0x40:
-		BTramdac_ID = ATT20C504_RAMDAC;
-		break;
-	case 0xD0:
-		BTramdac_ID = ATT20C505_RAMDAC;
-		break;
-	default:
-		xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-			   "Unknown BT RAMDAC type (0x%x), assuming BT485\n",
-			   status);
-	case 0x80:
-	case 0x90:
-	case 0xA0:
-	case 0xB0:
-	case 0x28: 	/* This is for the DEC TGA - Questionable ? */
-		BTramdac_ID = BT485_RAMDAC;
-		break;
+    case 0x40:
+        BTramdac_ID = ATT20C504_RAMDAC;
+        break;
+    case 0xD0:
+        BTramdac_ID = ATT20C505_RAMDAC;
+        break;
+    default:
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Unknown BT RAMDAC type (0x%x), assuming BT485\n", status);
+    case 0x80:
+    case 0x90:
+    case 0xA0:
+    case 0xB0:
+    case 0x28:                 /* This is for the DEC TGA - Questionable ? */
+        BTramdac_ID = BT485_RAMDAC;
+        break;
     }
 
     /* Restore COMMAND Register 0 */
-    (*ramdacPtr->WriteDAC)(pScrn, BT_COMMAND_REG_0, 0x00, cmd0);
+    (*ramdacPtr->WriteDAC) (pScrn, BT_COMMAND_REG_0, 0x00, cmd0);
 
     if (BTramdac_ID == -1) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Cannot determine BT RAMDAC type, aborting\n");
-	return NULL;
-    } else {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"Attached RAMDAC is %s\n", BTramdacDeviceInfo[BTramdac_ID&0xFFFF].DeviceName);
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Cannot determine BT RAMDAC type, aborting\n");
+        return NULL;
+    }
+    else {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Attached RAMDAC is %s\n",
+                   BTramdacDeviceInfo[BTramdac_ID & 0xFFFF].DeviceName);
     }
 
-    for (i=0;ramdacs[i].token != -1;i++) {
-	if (ramdacs[i].token == BTramdac_ID)
-	    RamDacIsSupported = TRUE;
+    for (i = 0; ramdacs[i].token != -1; i++) {
+        if (ramdacs[i].token == BTramdac_ID)
+            RamDacIsSupported = TRUE;
     }
 
     if (!RamDacIsSupported) {
-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 
-		"This BT RAMDAC is NOT supported by this driver, aborting\n");
-	return NULL;
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "This BT RAMDAC is NOT supported by this driver, aborting\n");
+        return NULL;
     }
 
     ramdacHelperPtr = RamDacHelperCreateInfoRec();
-    switch(BTramdac_ID) {
-	case BT485_RAMDAC:
-	    ramdacHelperPtr->SetBpp = BTramdacSetBpp;
-	    break;
+    switch (BTramdac_ID) {
+    case BT485_RAMDAC:
+        ramdacHelperPtr->SetBpp = BTramdacSetBpp;
+        break;
     }
     ramdacPtr->RamDacType = BTramdac_ID;
     ramdacHelperPtr->RamDacType = BTramdac_ID;
     ramdacHelperPtr->Save = BTramdacSave;
     ramdacHelperPtr->Restore = BTramdacRestore;
-	
+
     return ramdacHelperPtr;
 }
 
@@ -143,23 +145,23 @@ BTramdacSetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
     /* We need to deal with Direct Colour visuals for 8bpp and other
      * good stuff for colours */
     switch (pScrn->bitsPerPixel) {
-	case 32:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x10;
-	    break;
-	case 24:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x10;
-	    break;
-	case 16:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x38;
-	    break;
-	case 15:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x30;
-	    break;
-	case 8:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x40;
-	    break;
-	case 4:
-	    ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x60;
-	    break;
+    case 32:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x10;
+        break;
+    case 24:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x10;
+        break;
+    case 16:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x38;
+        break;
+    case 15:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x30;
+        break;
+    case 8:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x40;
+        break;
+    case 4:
+        ramdacReg->DacRegs[BT_COMMAND_REG_1] = 0x60;
+        break;
     }
 }
diff --git a/xorg-server/hw/xfree86/ramdac/BT.h b/xorg-server/hw/xfree86/ramdac/BT.h
index 35d0bdbd9..6eeaf5db7 100644
--- a/xorg-server/hw/xfree86/ramdac/BT.h
+++ b/xorg-server/hw/xfree86/ramdac/BT.h
@@ -1,10 +1,15 @@
 
 #include "xf86RamDac.h"
 
-extern _X_EXPORT RamDacHelperRecPtr BTramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs);
-extern _X_EXPORT void BTramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void BTramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void BTramdacSetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT RamDacHelperRecPtr BTramdacProbe(ScrnInfoPtr pScrn,
+                                                  RamDacSupportedInfoRecPtr
+                                                  ramdacs);
+extern _X_EXPORT void BTramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec,
+                                   RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void BTramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec,
+                                      RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void BTramdacSetBpp(ScrnInfoPtr pScrn,
+                                     RamDacRegRecPtr RamDacRegRec);
 
 #define ATT20C504_RAMDAC 	(VENDOR_BT << 16) | 0x00
 #define ATT20C505_RAMDAC 	(VENDOR_BT << 16) | 0x01
@@ -15,7 +20,7 @@ extern _X_EXPORT void BTramdacSetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRe
  */
 
 #define BT_WRITE_ADDR		0x00
-#define BT_RAMDAC_DATA		0x01	
+#define BT_RAMDAC_DATA		0x01
 #define BT_PIXEL_MASK		0x02
 #define BT_READ_ADDR		0x03
 #define BT_CURS_WR_ADDR		0x04
diff --git a/xorg-server/hw/xfree86/ramdac/IBM.c b/xorg-server/hw/xfree86/ramdac/IBM.c
index 3a477d7be..bc716231a 100644
--- a/xorg-server/hw/xfree86/ramdac/IBM.c
+++ b/xorg-server/hw/xfree86/ramdac/IBM.c
@@ -1,639 +1,643 @@
-/*

- * Copyright 1998 by Alan Hourihane, Wigan, England.

- *

- * Permission to use, copy, modify, distribute, and sell this software and its

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Alan Hourihane not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Alan Hourihane makes no representations

- * about the suitability of this software for any purpose.  It is provided

- * "as is" without express or implied warranty.

- *

- * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

- * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR

- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

- * PERFORMANCE OF THIS SOFTWARE.

- *

- * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>

- *

- * IBM RAMDAC routines.

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include "xf86.h"

-#include "xf86_OSproc.h"

-

-#include "xf86Cursor.h"

-

-#define INIT_IBM_RAMDAC_INFO

-#include "IBMPriv.h"

-#include "xf86RamDacPriv.h"

-

-#define INITIALFREQERR 100000

-

-unsigned long

-IBMramdac640CalculateMNPCForClock(

-    unsigned long RefClock,	/* In 100Hz units */

-    unsigned long ReqClock,	/* In 100Hz units */

-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

-    unsigned long MinClock,	/* Min VCO rating */

-    unsigned long MaxClock,	/* Max VCO rating */

-    unsigned long *rM,	/* M Out */

-    unsigned long *rN,	/* N Out */

-    unsigned long *rP,	/* Min P In, P Out */

-    unsigned long *rC	/* C Out */

-)

-{

-  unsigned long   M, N, P, iP = *rP;

-  unsigned long   IntRef, VCO, Clock;

-  long            freqErr, lowestFreqErr = INITIALFREQERR;

-  unsigned long   ActualClock = 0;

-

-  for (N = 0; N <= 63; N++)

-    {

-      IntRef = RefClock / (N + 1);

-      if (IntRef < 10000)

-	break;			/* IntRef needs to be >= 1MHz */

-      for (M = 2; M <= 127; M++)

-	{

-	  VCO = IntRef * (M + 1);

-	  if ((VCO < MinClock) || (VCO > MaxClock))

-	    continue;

-	  for (P = iP; P <= 4; P++)

-	    {

-	      if (P != 0)

-		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);

-	      else

-		Clock = (RefClock * (M + 1)) / (N + 1);

-

-	      freqErr = (Clock - ReqClock);

-

-	      if (freqErr < 0)

-		{

-		  /* PixelClock gets rounded up always so monitor reports

-		     correct frequency. */

-		  if (IsPixClock)

-		    continue;

-		  freqErr = -freqErr;

-		}

-

-	      if (freqErr < lowestFreqErr)

-		{

-		  *rM = M;

-		  *rN = N;

-		  *rP = P;

-		  *rC = (VCO <= 1280000 ? 1 : 2);

-		  ActualClock = Clock;

-

-		  lowestFreqErr = freqErr;

-		  /* Return if we found an exact match */

-		  if (freqErr == 0)

-		    return ActualClock;

-		}

-	    }

-	}

-    }

-

-  return ActualClock;

-}

-

-unsigned long

-IBMramdac526CalculateMNPCForClock(

-    unsigned long RefClock,	/* In 100Hz units */

-    unsigned long ReqClock,	/* In 100Hz units */

-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

-    unsigned long MinClock,	/* Min VCO rating */

-    unsigned long MaxClock,	/* Max VCO rating */

-    unsigned long *rM,	/* M Out */

-    unsigned long *rN,	/* N Out */

-    unsigned long *rP,	/* Min P In, P Out */

-    unsigned long *rC	/* C Out */

-)

-{

-  unsigned long   M, N, P, iP = *rP;

-  unsigned long   IntRef, VCO, Clock;

-  long            freqErr, lowestFreqErr = INITIALFREQERR;

-  unsigned long   ActualClock = 0;

-

-  for (N = 0; N <= 63; N++)

-    {

-      IntRef = RefClock / (N + 1);

-      if (IntRef < 10000)

-	break;			/* IntRef needs to be >= 1MHz */

-      for (M = 0; M <= 63; M++)

-	{

-	  VCO = IntRef * (M + 1);

-	  if ((VCO < MinClock) || (VCO > MaxClock))

-	    continue;

-	  for (P = iP; P <= 4; P++)

-	    {

-	      if (P)

-		Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);

-	      else

-		Clock = VCO;

-

-	      freqErr = (Clock - ReqClock);

-

-	      if (freqErr < 0)

-		{

-		  /* PixelClock gets rounded up always so monitor reports

-		     correct frequency. */

-		  if (IsPixClock)

-		    continue;

-		  freqErr = -freqErr;

-		}

-

-	      if (freqErr < lowestFreqErr)

-		{

-		  *rM = M;

-		  *rN = N;

-		  *rP = P;

-		  *rC = (VCO <= 1280000 ? 1 : 2);

-		  ActualClock = Clock;

-

-		  lowestFreqErr = freqErr;

-		  /* Return if we found an exact match */

-		  if (freqErr == 0)

-		    return ActualClock;

-		}

-	    }

-	}

-    }

-

-  return ActualClock;

-}

-

-void

-IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,

-				    RamDacRegRecPtr ramdacReg)

-{

-	int i, maxreg, dacreg;

-

-	switch (ramdacPtr->RamDacType) {

-	    case IBM640_RAMDAC:

-		maxreg = 0x300;

-		dacreg = 1024;

-		break;

-	    default:

-		maxreg = 0x100;

-		dacreg = 768;

-		break;

-	}

-

-	/* Here we pass a short, so that we can evaluate a mask too */

-	/* So that the mask is the high byte and the data the low byte */

-	for (i=0;i<maxreg;i++) 

-	    (*ramdacPtr->WriteDAC)

-	        (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8, 

-						ramdacReg->DacRegs[i]);

-

-	(*ramdacPtr->WriteAddress)(pScrn, 0);

-	for (i=0;i<dacreg;i++)

-	    	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);

-}

-

-void

-IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 

-				 RamDacRegRecPtr ramdacReg)

-{

-	int i, maxreg, dacreg;

-

-	switch (ramdacPtr->RamDacType) {

-	    case IBM640_RAMDAC:

-		maxreg = 0x300;

-		dacreg = 1024;

-		break;

-	    default:

-		maxreg = 0x100;

-		dacreg = 768;

-		break;

-	}

-	

-	(*ramdacPtr->ReadAddress)(pScrn, 0);

-	for (i=0;i<dacreg;i++)

-	    ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);

-

-	for (i=0;i<maxreg;i++) 

-	    ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC)(pScrn, i);

-}

-

-RamDacHelperRecPtr

-IBMramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs/* , RamDacRecPtr ramdacPtr*/)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-    RamDacHelperRecPtr ramdacHelperPtr = NULL;

-    Bool RamDacIsSupported = FALSE;

-    int IBMramdac_ID = -1;

-    int i;

-    unsigned char id, rev, id2, rev2;

-

-    /* read ID and revision */

-    rev = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);

-    id = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);

-

-    /* check if ID and revision are read only */

-    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, IBMRGB_rev);

-    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, IBMRGB_id);

-    rev2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_rev);

-    id2 = (*ramdacPtr->ReadDAC)(pScrn, IBMRGB_id);

-

-    switch (id) {

-	case 0x30:

-		if (rev == 0xc0) IBMramdac_ID = IBM624_RAMDAC;

-		if (rev == 0x80) IBMramdac_ID = IBM624DB_RAMDAC;

-		break;

-	case 0x12:

-		if (rev == 0x1c) IBMramdac_ID = IBM640_RAMDAC;

-		break;

-	case 0x01:

-		IBMramdac_ID = IBM525_RAMDAC;

-		break;

-	case 0x02:

-		if (rev == 0xf0) IBMramdac_ID = IBM524_RAMDAC;

-		if (rev == 0xe0) IBMramdac_ID = IBM524A_RAMDAC;

-		if (rev == 0xc0) IBMramdac_ID = IBM526_RAMDAC;

-		if (rev == 0x80) IBMramdac_ID = IBM526DB_RAMDAC;

-		break;

-    }

-

-    if (id == 1 || id == 2) {

-        if (id == id2 && rev == rev2) {		/* IBM RGB52x found */

-	    /* check for 128bit VRAM -> RGB528 */

-	    if (((*ramdacPtr->ReadDAC)(pScrn, IBMRGB_misc1) & 0x03) == 0x03) {

-	        IBMramdac_ID = IBM528_RAMDAC;	/* 128bit DAC found */

-	        if (rev == 0xe0)

-		    IBMramdac_ID = IBM528A_RAMDAC;

-	    }

-        }

-    }

-

-    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, IBMRGB_rev);

-    (*ramdacPtr->WriteDAC)(pScrn, id, 0, IBMRGB_id);

-

-    if (IBMramdac_ID == -1) {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"Cannot determine IBM RAMDAC type, aborting\n");

-	return NULL;

-    } else {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"Attached RAMDAC is %s\n", IBMramdacDeviceInfo[IBMramdac_ID&0xFFFF].DeviceName);

-    }

-

-    for (i=0;ramdacs[i].token != -1;i++) {

-	if (ramdacs[i].token == IBMramdac_ID)

-	    RamDacIsSupported = TRUE;

-    }

-

-    if (!RamDacIsSupported) {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"This IBM RAMDAC is NOT supported by this driver, aborting\n");

-	return NULL;

-    }

-

-    ramdacHelperPtr = RamDacHelperCreateInfoRec();

-    switch (IBMramdac_ID) {

-	case IBM526_RAMDAC:

-	case IBM526DB_RAMDAC:

- 	    ramdacHelperPtr->SetBpp = IBMramdac526SetBpp;

-    	    ramdacHelperPtr->HWCursorInit = IBMramdac526HWCursorInit;

-	    break;

-	case IBM640_RAMDAC:

- 	    ramdacHelperPtr->SetBpp = IBMramdac640SetBpp;

-    	    ramdacHelperPtr->HWCursorInit = IBMramdac640HWCursorInit;

-	    break;

-    }

-    ramdacPtr->RamDacType = IBMramdac_ID;

-    ramdacHelperPtr->RamDacType = IBMramdac_ID;

-    ramdacHelperPtr->Save = IBMramdacSave;

-    ramdacHelperPtr->Restore = IBMramdacRestore;

-

-    return ramdacHelperPtr;

-}

-

-void

-IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

-{

-    ramdacReg->DacRegs[IBMRGB_key_control] = 0x00; /* Disable Chroma Key */

-

-    switch (pScrn->bitsPerPixel) {

-	case 32:

-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_32BPP;

-	    ramdacReg->DacRegs[IBMRGB_32bpp] = B32_DCOL_DIRECT;

-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

-	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

-		ramdacReg->DacRegs[IBMRGB_key_control] = 0x01; /* Enable Key */

-		ramdacReg->DacRegs[IBMRGB_key] = 0xFF; 

-		ramdacReg->DacRegs[IBMRGB_key_mask] = 0xFF;

-	    }

-	    break;

-	case 24:

-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_24BPP;

-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_24bpp] = B24_DCOL_DIRECT;

-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

-	    break;

-	case 16:

-	    if (pScrn->depth == 16) {

-	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;

-	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

-	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

-	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |

-					           B16_CONTIGUOUS | B16_565;

-	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

-	    } else {

-	        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;

-	        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

-	        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

-	        ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT|B16_LINEAR |

-					           B16_CONTIGUOUS | B16_555;

-	        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

-	    }

-	    break;

-	case 8:

-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_8BPP;

-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_8bpp] = B8_DCOL_INDIRECT;

-	    break;

-	case 4:

-	    ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_4BPP;

-	    ramdacReg->DacRegs[IBMRGB_32bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_24bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_16bpp] = 0;

-	    ramdacReg->DacRegs[IBMRGB_8bpp] = 0;

-    }

-}

-

-IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void) {

-    return IBMramdac526SetBpp;

-}

-

-void

-IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

-{

-    unsigned char bpp = 0x00;

-    unsigned char overlaybpp = 0x00;

-    unsigned char offset = 0x00;

-    unsigned char dispcont = 0x44;

-

-    ramdacReg->DacRegs[RGB640_SER_WID_03_00] = 0x00;

-    ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x00;

-    ramdacReg->DacRegs[RGB640_DIAGS] = 0x07;

-

-    switch (pScrn->depth) {

-	case 8:

-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x00; 

-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x00;

-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_16_1; /*16:1 Mux*/

-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

-	    bpp = 0x03;

-	    break;

-	case 15:

-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;

-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;

-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/

-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

-	    bpp = 0x0E;

-	    break;

-	case 16:

-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;

-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;

-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;

-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;

-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1; /* 8:1 Mux*/

-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

-	    bpp = 0x05;

-	    break;

-	case 24:

-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 

-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;

-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;

-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;

-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/

-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8; /* pll / 8 */

-	    bpp = 0x09;

-	    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

-		ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x04;

-		ramdacReg->DacRegs[RGB640_CHROMA_KEY0] = 0xFF;

-		ramdacReg->DacRegs[RGB640_CHROMA_MASK0] = 0xFF;

-		offset = 0x04;

-		overlaybpp = 0x04;

-		dispcont = 0x48;

-	    }

-	    break;

-	case 30: /* 10 bit dac */

-	    ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30; 

-	    ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;

-	    ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;

-	    ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;

-    	    ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1; /* 4:1 Mux*/

-    	    ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PSIZE10 | 

-						   IBM640_PCLK_8; /* pll / 8 */

-	    bpp = 0x0D;

-	    break;

-    }

-	

-    { 

-	int i;

-    	for (i=0x100;i<0x140;i+=4) {

-	    /* Initialize FrameBuffer Window Attribute Table */

-	    ramdacReg->DacRegs[i+0] = bpp;

-	    ramdacReg->DacRegs[i+1] = offset;

-	    ramdacReg->DacRegs[i+2] = 0x00;

-	    ramdacReg->DacRegs[i+3] = 0x00;

-	    /* Initialize Overlay Window Attribute Table */

-	    ramdacReg->DacRegs[i+0x100] = overlaybpp;

-	    ramdacReg->DacRegs[i+0x101] = 0x00;

-	    ramdacReg->DacRegs[i+0x102] = 0x00;

-	    ramdacReg->DacRegs[i+0x103] = dispcont;

-        }

-    }

-}

-

-static void 

-IBMramdac526ShowCursor(ScrnInfoPtr pScrn)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   /* Enable cursor - X11 mode */

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x07);

-}

-

-static void 

-IBMramdac640ShowCursor(ScrnInfoPtr pScrn)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   /* Enable cursor - mode2 (x11 mode) */

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x0B);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CROSSHAIR_CONTROL, 0x00, 0x00);

-}

-

-static void

-IBMramdac526HideCursor(ScrnInfoPtr pScrn)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   /* Disable cursor - X11 mode */

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs, 0x00, 0x24);

-}

-

-static void

-IBMramdac640HideCursor(ScrnInfoPtr pScrn)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   /* Disable cursor - mode2 (x11 mode) */

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x08);

-}

-

-static void

-IBMramdac526SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   x += 64;

-   y += 64;

-

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_x, 0x00, 0x3f);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_hot_y, 0x00, 0x3f);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xl, 0x00, x & 0xff);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_xh, 0x00, (x>>8) & 0xf);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yl, 0x00, y & 0xff);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_yh, 0x00, (y>>8) & 0xf);

-}

-

-static void

-IBMramdac640SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   x += 64;

-   y += 64;

-

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETX, 0x00, 0x3f);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_OFFSETY, 0x00, 0x3f);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_LOW, 0x00, x & 0xff);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_X_HIGH, 0x00, (x>>8) & 0xf);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_LOW, 0x00, y & 0xff);

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_Y_HIGH, 0x00, (y>>8) & 0xf);

-}

-

-static void

-IBMramdac526SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_r, 0x00, bg >> 16);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_g, 0x00, bg >> 8);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col1_b, 0x00, bg);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_r, 0x00, fg >> 16);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_g, 0x00, fg >> 8);

-   (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_col2_b, 0x00, fg);

-}

-

-static void

-IBMramdac640SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-  

-   (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_COL0, 0x00, 0);

-   (*ramdacPtr->WriteData)(pScrn, fg>>16);

-   (*ramdacPtr->WriteData)(pScrn, fg>>8);

-   (*ramdacPtr->WriteData)(pScrn, fg);

-   (*ramdacPtr->WriteData)(pScrn, bg>>16);

-   (*ramdacPtr->WriteData)(pScrn, bg>>8);

-   (*ramdacPtr->WriteData)(pScrn, bg);

-   (*ramdacPtr->WriteData)(pScrn, fg>>16);

-   (*ramdacPtr->WriteData)(pScrn, fg>>8);

-   (*ramdacPtr->WriteData)(pScrn, fg);

-   (*ramdacPtr->WriteData)(pScrn, bg>>16);

-   (*ramdacPtr->WriteData)(pScrn, bg>>8);

-   (*ramdacPtr->WriteData)(pScrn, bg);

-}

-

-static void 

-IBMramdac526LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-   int i;

-   /* 

-    * Output the cursor data.  The realize function has put the planes into

-    * their correct order, so we can just blast this out.

-    */

-   for (i = 0; i < 1024; i++)

-      (*ramdacPtr->WriteDAC)(pScrn, IBMRGB_curs_array + i, 0x00, (*src++));

-}

-

-static void 

-IBMramdac640LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

-{

-   RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-   int i;

-   /* 

-    * Output the cursor data.  The realize function has put the planes into

-    * their correct order, so we can just blast this out.

-    */

-   for (i = 0; i < 1024; i++)

-      (*ramdacPtr->WriteDAC)(pScrn, RGB640_CURS_WRITE + i, 0x00, (*src++));

-}

-

-static Bool 

-IBMramdac526UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

-{

-    return TRUE;

-}

-

-static Bool 

-IBMramdac640UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

-{

-    return TRUE;

-}

-

-void

-IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr)

-{

-    infoPtr->MaxWidth = 64;

-    infoPtr->MaxHeight = 64;

-    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

-		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |

-		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;

-    infoPtr->SetCursorColors = IBMramdac526SetCursorColors;

-    infoPtr->SetCursorPosition = IBMramdac526SetCursorPosition;

-    infoPtr->LoadCursorImage = IBMramdac526LoadCursorImage;

-    infoPtr->HideCursor = IBMramdac526HideCursor;

-    infoPtr->ShowCursor = IBMramdac526ShowCursor;

-    infoPtr->UseHWCursor = IBMramdac526UseHWCursor;

-}

-

-void

-IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr)

-{

-    infoPtr->MaxWidth = 64;

-    infoPtr->MaxHeight = 64;

-    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

-		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |

-		     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;

-    infoPtr->SetCursorColors = IBMramdac640SetCursorColors;

-    infoPtr->SetCursorPosition = IBMramdac640SetCursorPosition;

-    infoPtr->LoadCursorImage = IBMramdac640LoadCursorImage;

-    infoPtr->HideCursor = IBMramdac640HideCursor;

-    infoPtr->ShowCursor = IBMramdac640ShowCursor;

-    infoPtr->UseHWCursor = IBMramdac640UseHWCursor;

-}

+/*
+ * Copyright 1998 by Alan Hourihane, Wigan, England.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Alan Hourihane not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Alan Hourihane makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
+ *
+ * IBM RAMDAC routines.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+
+#include "xf86Cursor.h"
+
+#define INIT_IBM_RAMDAC_INFO
+#include "IBMPriv.h"
+#include "xf86RamDacPriv.h"
+
+#define INITIALFREQERR 100000
+
+unsigned long
+IBMramdac640CalculateMNPCForClock(unsigned long RefClock,       /* In 100Hz units */
+                                  unsigned long ReqClock,       /* In 100Hz units */
+                                  char IsPixClock,      /* boolean, is this the pixel or the sys clock */
+                                  unsigned long MinClock,       /* Min VCO rating */
+                                  unsigned long MaxClock,       /* Max VCO rating */
+                                  unsigned long *rM,    /* M Out */
+                                  unsigned long *rN,    /* N Out */
+                                  unsigned long *rP,    /* Min P In, P Out */
+                                  unsigned long *rC     /* C Out */
+    )
+{
+    unsigned long M, N, P, iP = *rP;
+    unsigned long IntRef, VCO, Clock;
+    long freqErr, lowestFreqErr = INITIALFREQERR;
+    unsigned long ActualClock = 0;
+
+    for (N = 0; N <= 63; N++) {
+        IntRef = RefClock / (N + 1);
+        if (IntRef < 10000)
+            break;              /* IntRef needs to be >= 1MHz */
+        for (M = 2; M <= 127; M++) {
+            VCO = IntRef * (M + 1);
+            if ((VCO < MinClock) || (VCO > MaxClock))
+                continue;
+            for (P = iP; P <= 4; P++) {
+                if (P != 0)
+                    Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
+                else
+                    Clock = (RefClock * (M + 1)) / (N + 1);
+
+                freqErr = (Clock - ReqClock);
+
+                if (freqErr < 0) {
+                    /* PixelClock gets rounded up always so monitor reports
+                       correct frequency. */
+                    if (IsPixClock)
+                        continue;
+                    freqErr = -freqErr;
+                }
+
+                if (freqErr < lowestFreqErr) {
+                    *rM = M;
+                    *rN = N;
+                    *rP = P;
+                    *rC = (VCO <= 1280000 ? 1 : 2);
+                    ActualClock = Clock;
+
+                    lowestFreqErr = freqErr;
+                    /* Return if we found an exact match */
+                    if (freqErr == 0)
+                        return ActualClock;
+                }
+            }
+        }
+    }
+
+    return ActualClock;
+}
+
+unsigned long
+IBMramdac526CalculateMNPCForClock(unsigned long RefClock,       /* In 100Hz units */
+                                  unsigned long ReqClock,       /* In 100Hz units */
+                                  char IsPixClock,      /* boolean, is this the pixel or the sys clock */
+                                  unsigned long MinClock,       /* Min VCO rating */
+                                  unsigned long MaxClock,       /* Max VCO rating */
+                                  unsigned long *rM,    /* M Out */
+                                  unsigned long *rN,    /* N Out */
+                                  unsigned long *rP,    /* Min P In, P Out */
+                                  unsigned long *rC     /* C Out */
+    )
+{
+    unsigned long M, N, P, iP = *rP;
+    unsigned long IntRef, VCO, Clock;
+    long freqErr, lowestFreqErr = INITIALFREQERR;
+    unsigned long ActualClock = 0;
+
+    for (N = 0; N <= 63; N++) {
+        IntRef = RefClock / (N + 1);
+        if (IntRef < 10000)
+            break;              /* IntRef needs to be >= 1MHz */
+        for (M = 0; M <= 63; M++) {
+            VCO = IntRef * (M + 1);
+            if ((VCO < MinClock) || (VCO > MaxClock))
+                continue;
+            for (P = iP; P <= 4; P++) {
+                if (P)
+                    Clock = (RefClock * (M + 1)) / ((N + 1) * 2 * P);
+                else
+                    Clock = VCO;
+
+                freqErr = (Clock - ReqClock);
+
+                if (freqErr < 0) {
+                    /* PixelClock gets rounded up always so monitor reports
+                       correct frequency. */
+                    if (IsPixClock)
+                        continue;
+                    freqErr = -freqErr;
+                }
+
+                if (freqErr < lowestFreqErr) {
+                    *rM = M;
+                    *rN = N;
+                    *rP = P;
+                    *rC = (VCO <= 1280000 ? 1 : 2);
+                    ActualClock = Clock;
+
+                    lowestFreqErr = freqErr;
+                    /* Return if we found an exact match */
+                    if (freqErr == 0)
+                        return ActualClock;
+                }
+            }
+        }
+    }
+
+    return ActualClock;
+}
+
+void
+IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
+                 RamDacRegRecPtr ramdacReg)
+{
+    int i, maxreg, dacreg;
+
+    switch (ramdacPtr->RamDacType) {
+    case IBM640_RAMDAC:
+        maxreg = 0x300;
+        dacreg = 1024;
+        break;
+    default:
+        maxreg = 0x100;
+        dacreg = 768;
+        break;
+    }
+
+    /* Here we pass a short, so that we can evaluate a mask too */
+    /* So that the mask is the high byte and the data the low byte */
+    for (i = 0; i < maxreg; i++)
+        (*ramdacPtr->WriteDAC)
+            (pScrn, i, (ramdacReg->DacRegs[i] & 0xFF00) >> 8,
+             ramdacReg->DacRegs[i]);
+
+    (*ramdacPtr->WriteAddress) (pScrn, 0);
+    for (i = 0; i < dacreg; i++)
+        (*ramdacPtr->WriteData) (pScrn, ramdacReg->DAC[i]);
+}
+
+void
+IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
+              RamDacRegRecPtr ramdacReg)
+{
+    int i, maxreg, dacreg;
+
+    switch (ramdacPtr->RamDacType) {
+    case IBM640_RAMDAC:
+        maxreg = 0x300;
+        dacreg = 1024;
+        break;
+    default:
+        maxreg = 0x100;
+        dacreg = 768;
+        break;
+    }
+
+    (*ramdacPtr->ReadAddress) (pScrn, 0);
+    for (i = 0; i < dacreg; i++)
+        ramdacReg->DAC[i] = (*ramdacPtr->ReadData) (pScrn);
+
+    for (i = 0; i < maxreg; i++)
+        ramdacReg->DacRegs[i] = (*ramdacPtr->ReadDAC) (pScrn, i);
+}
+
+RamDacHelperRecPtr
+IBMramdacProbe(ScrnInfoPtr pScrn,
+               RamDacSupportedInfoRecPtr ramdacs /* , RamDacRecPtr ramdacPtr */
+               )
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+    RamDacHelperRecPtr ramdacHelperPtr = NULL;
+    Bool RamDacIsSupported = FALSE;
+    int IBMramdac_ID = -1;
+    int i;
+    unsigned char id, rev, id2, rev2;
+
+    /* read ID and revision */
+    rev = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_rev);
+    id = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_id);
+
+    /* check if ID and revision are read only */
+    (*ramdacPtr->WriteDAC) (pScrn, ~rev, 0, IBMRGB_rev);
+    (*ramdacPtr->WriteDAC) (pScrn, ~id, 0, IBMRGB_id);
+    rev2 = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_rev);
+    id2 = (*ramdacPtr->ReadDAC) (pScrn, IBMRGB_id);
+
+    switch (id) {
+    case 0x30:
+        if (rev == 0xc0)
+            IBMramdac_ID = IBM624_RAMDAC;
+        if (rev == 0x80)
+            IBMramdac_ID = IBM624DB_RAMDAC;
+        break;
+    case 0x12:
+        if (rev == 0x1c)
+            IBMramdac_ID = IBM640_RAMDAC;
+        break;
+    case 0x01:
+        IBMramdac_ID = IBM525_RAMDAC;
+        break;
+    case 0x02:
+        if (rev == 0xf0)
+            IBMramdac_ID = IBM524_RAMDAC;
+        if (rev == 0xe0)
+            IBMramdac_ID = IBM524A_RAMDAC;
+        if (rev == 0xc0)
+            IBMramdac_ID = IBM526_RAMDAC;
+        if (rev == 0x80)
+            IBMramdac_ID = IBM526DB_RAMDAC;
+        break;
+    }
+
+    if (id == 1 || id == 2) {
+        if (id == id2 && rev == rev2) { /* IBM RGB52x found */
+            /* check for 128bit VRAM -> RGB528 */
+            if (((*ramdacPtr->ReadDAC) (pScrn, IBMRGB_misc1) & 0x03) == 0x03) {
+                IBMramdac_ID = IBM528_RAMDAC;   /* 128bit DAC found */
+                if (rev == 0xe0)
+                    IBMramdac_ID = IBM528A_RAMDAC;
+            }
+        }
+    }
+
+    (*ramdacPtr->WriteDAC) (pScrn, rev, 0, IBMRGB_rev);
+    (*ramdacPtr->WriteDAC) (pScrn, id, 0, IBMRGB_id);
+
+    if (IBMramdac_ID == -1) {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Cannot determine IBM RAMDAC type, aborting\n");
+        return NULL;
+    }
+    else {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Attached RAMDAC is %s\n",
+                   IBMramdacDeviceInfo[IBMramdac_ID & 0xFFFF].DeviceName);
+    }
+
+    for (i = 0; ramdacs[i].token != -1; i++) {
+        if (ramdacs[i].token == IBMramdac_ID)
+            RamDacIsSupported = TRUE;
+    }
+
+    if (!RamDacIsSupported) {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "This IBM RAMDAC is NOT supported by this driver, aborting\n");
+        return NULL;
+    }
+
+    ramdacHelperPtr = RamDacHelperCreateInfoRec();
+    switch (IBMramdac_ID) {
+    case IBM526_RAMDAC:
+    case IBM526DB_RAMDAC:
+        ramdacHelperPtr->SetBpp = IBMramdac526SetBpp;
+        ramdacHelperPtr->HWCursorInit = IBMramdac526HWCursorInit;
+        break;
+    case IBM640_RAMDAC:
+        ramdacHelperPtr->SetBpp = IBMramdac640SetBpp;
+        ramdacHelperPtr->HWCursorInit = IBMramdac640HWCursorInit;
+        break;
+    }
+    ramdacPtr->RamDacType = IBMramdac_ID;
+    ramdacHelperPtr->RamDacType = IBMramdac_ID;
+    ramdacHelperPtr->Save = IBMramdacSave;
+    ramdacHelperPtr->Restore = IBMramdacRestore;
+
+    return ramdacHelperPtr;
+}
+
+void
+IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
+{
+    ramdacReg->DacRegs[IBMRGB_key_control] = 0x00;      /* Disable Chroma Key */
+
+    switch (pScrn->bitsPerPixel) {
+    case 32:
+        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_32BPP;
+        ramdacReg->DacRegs[IBMRGB_32bpp] = B32_DCOL_DIRECT;
+        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
+        if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
+            ramdacReg->DacRegs[IBMRGB_key_control] = 0x01;      /* Enable Key */
+            ramdacReg->DacRegs[IBMRGB_key] = 0xFF;
+            ramdacReg->DacRegs[IBMRGB_key_mask] = 0xFF;
+        }
+        break;
+    case 24:
+        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_24BPP;
+        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_24bpp] = B24_DCOL_DIRECT;
+        ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
+        break;
+    case 16:
+        if (pScrn->depth == 16) {
+            ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
+            ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
+            ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
+            ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT | B16_LINEAR |
+                B16_CONTIGUOUS | B16_565;
+            ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
+        }
+        else {
+            ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_16BPP;
+            ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
+            ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
+            ramdacReg->DacRegs[IBMRGB_16bpp] = B16_DCOL_DIRECT | B16_LINEAR |
+                B16_CONTIGUOUS | B16_555;
+            ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
+        }
+        break;
+    case 8:
+        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_8BPP;
+        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_8bpp] = B8_DCOL_INDIRECT;
+        break;
+    case 4:
+        ramdacReg->DacRegs[IBMRGB_pix_fmt] = PIXEL_FORMAT_4BPP;
+        ramdacReg->DacRegs[IBMRGB_32bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_24bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_16bpp] = 0;
+        ramdacReg->DacRegs[IBMRGB_8bpp] = 0;
+    }
+}
+
+IBMramdac526SetBppProc *
+IBMramdac526SetBppWeak(void)
+{
+    return IBMramdac526SetBpp;
+}
+
+void
+IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
+{
+    unsigned char bpp = 0x00;
+    unsigned char overlaybpp = 0x00;
+    unsigned char offset = 0x00;
+    unsigned char dispcont = 0x44;
+
+    ramdacReg->DacRegs[RGB640_SER_WID_03_00] = 0x00;
+    ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x00;
+    ramdacReg->DacRegs[RGB640_DIAGS] = 0x07;
+
+    switch (pScrn->depth) {
+    case 8:
+        ramdacReg->DacRegs[RGB640_SER_07_00] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_15_08] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_16_1;  /*16:1 Mux */
+        ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8;   /* pll / 8 */
+        bpp = 0x03;
+        break;
+    case 15:
+        ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
+        ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
+        ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1;   /* 8:1 Mux */
+        ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8;   /* pll / 8 */
+        bpp = 0x0E;
+        break;
+    case 16:
+        ramdacReg->DacRegs[RGB640_SER_07_00] = 0x10;
+        ramdacReg->DacRegs[RGB640_SER_15_08] = 0x11;
+        ramdacReg->DacRegs[RGB640_SER_23_16] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_31_24] = 0x00;
+        ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_8_1;   /* 8:1 Mux */
+        ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8;   /* pll / 8 */
+        bpp = 0x05;
+        break;
+    case 24:
+        ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30;
+        ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
+        ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
+        ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
+        ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1;   /* 4:1 Mux */
+        ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PCLK_8;   /* pll / 8 */
+        bpp = 0x09;
+        if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
+            ramdacReg->DacRegs[RGB640_SER_WID_07_04] = 0x04;
+            ramdacReg->DacRegs[RGB640_CHROMA_KEY0] = 0xFF;
+            ramdacReg->DacRegs[RGB640_CHROMA_MASK0] = 0xFF;
+            offset = 0x04;
+            overlaybpp = 0x04;
+            dispcont = 0x48;
+        }
+        break;
+    case 30:                   /* 10 bit dac */
+        ramdacReg->DacRegs[RGB640_SER_07_00] = 0x30;
+        ramdacReg->DacRegs[RGB640_SER_15_08] = 0x31;
+        ramdacReg->DacRegs[RGB640_SER_23_16] = 0x32;
+        ramdacReg->DacRegs[RGB640_SER_31_24] = 0x33;
+        ramdacReg->DacRegs[RGB640_SER_MODE] = IBM640_SER_4_1;   /* 4:1 Mux */
+        ramdacReg->DacRegs[RGB640_MISC_CONF] = IBM640_PSIZE10 | IBM640_PCLK_8;  /* pll / 8 */
+        bpp = 0x0D;
+        break;
+    }
+
+    {
+        int i;
+
+        for (i = 0x100; i < 0x140; i += 4) {
+            /* Initialize FrameBuffer Window Attribute Table */
+            ramdacReg->DacRegs[i + 0] = bpp;
+            ramdacReg->DacRegs[i + 1] = offset;
+            ramdacReg->DacRegs[i + 2] = 0x00;
+            ramdacReg->DacRegs[i + 3] = 0x00;
+            /* Initialize Overlay Window Attribute Table */
+            ramdacReg->DacRegs[i + 0x100] = overlaybpp;
+            ramdacReg->DacRegs[i + 0x101] = 0x00;
+            ramdacReg->DacRegs[i + 0x102] = 0x00;
+            ramdacReg->DacRegs[i + 0x103] = dispcont;
+        }
+    }
+}
+
+static void
+IBMramdac526ShowCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Enable cursor - X11 mode */
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs, 0x00, 0x07);
+}
+
+static void
+IBMramdac640ShowCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Enable cursor - mode2 (x11 mode) */
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x0B);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CROSSHAIR_CONTROL, 0x00, 0x00);
+}
+
+static void
+IBMramdac526HideCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Disable cursor - X11 mode */
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs, 0x00, 0x24);
+}
+
+static void
+IBMramdac640HideCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Disable cursor - mode2 (x11 mode) */
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURSOR_CONTROL, 0x00, 0x08);
+}
+
+static void
+IBMramdac526SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    x += 64;
+    y += 64;
+
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_hot_x, 0x00, 0x3f);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_hot_y, 0x00, 0x3f);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_xl, 0x00, x & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_xh, 0x00, (x >> 8) & 0xf);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_yl, 0x00, y & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_yh, 0x00, (y >> 8) & 0xf);
+}
+
+static void
+IBMramdac640SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    x += 64;
+    y += 64;
+
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_OFFSETX, 0x00, 0x3f);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_OFFSETY, 0x00, 0x3f);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_X_LOW, 0x00, x & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_X_HIGH, 0x00, (x >> 8) & 0xf);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_Y_LOW, 0x00, y & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_Y_HIGH, 0x00, (y >> 8) & 0xf);
+}
+
+static void
+IBMramdac526SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_r, 0x00, bg >> 16);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_g, 0x00, bg >> 8);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col1_b, 0x00, bg);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_r, 0x00, fg >> 16);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_g, 0x00, fg >> 8);
+    (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_col2_b, 0x00, fg);
+}
+
+static void
+IBMramdac640SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_COL0, 0x00, 0);
+    (*ramdacPtr->WriteData) (pScrn, fg >> 16);
+    (*ramdacPtr->WriteData) (pScrn, fg >> 8);
+    (*ramdacPtr->WriteData) (pScrn, fg);
+    (*ramdacPtr->WriteData) (pScrn, bg >> 16);
+    (*ramdacPtr->WriteData) (pScrn, bg >> 8);
+    (*ramdacPtr->WriteData) (pScrn, bg);
+    (*ramdacPtr->WriteData) (pScrn, fg >> 16);
+    (*ramdacPtr->WriteData) (pScrn, fg >> 8);
+    (*ramdacPtr->WriteData) (pScrn, fg);
+    (*ramdacPtr->WriteData) (pScrn, bg >> 16);
+    (*ramdacPtr->WriteData) (pScrn, bg >> 8);
+    (*ramdacPtr->WriteData) (pScrn, bg);
+}
+
+static void
+IBMramdac526LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+    int i;
+
+    /* 
+     * Output the cursor data.  The realize function has put the planes into
+     * their correct order, so we can just blast this out.
+     */
+    for (i = 0; i < 1024; i++)
+        (*ramdacPtr->WriteDAC) (pScrn, IBMRGB_curs_array + i, 0x00, (*src++));
+}
+
+static void
+IBMramdac640LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+    int i;
+
+    /* 
+     * Output the cursor data.  The realize function has put the planes into
+     * their correct order, so we can just blast this out.
+     */
+    for (i = 0; i < 1024; i++)
+        (*ramdacPtr->WriteDAC) (pScrn, RGB640_CURS_WRITE + i, 0x00, (*src++));
+}
+
+static Bool
+IBMramdac526UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
+{
+    return TRUE;
+}
+
+static Bool
+IBMramdac640UseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
+{
+    return TRUE;
+}
+
+void
+IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr)
+{
+    infoPtr->MaxWidth = 64;
+    infoPtr->MaxHeight = 64;
+    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
+        HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
+        HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
+    infoPtr->SetCursorColors = IBMramdac526SetCursorColors;
+    infoPtr->SetCursorPosition = IBMramdac526SetCursorPosition;
+    infoPtr->LoadCursorImage = IBMramdac526LoadCursorImage;
+    infoPtr->HideCursor = IBMramdac526HideCursor;
+    infoPtr->ShowCursor = IBMramdac526ShowCursor;
+    infoPtr->UseHWCursor = IBMramdac526UseHWCursor;
+}
+
+void
+IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr)
+{
+    infoPtr->MaxWidth = 64;
+    infoPtr->MaxHeight = 64;
+    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
+        HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
+        HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1;
+    infoPtr->SetCursorColors = IBMramdac640SetCursorColors;
+    infoPtr->SetCursorPosition = IBMramdac640SetCursorPosition;
+    infoPtr->LoadCursorImage = IBMramdac640LoadCursorImage;
+    infoPtr->HideCursor = IBMramdac640HideCursor;
+    infoPtr->ShowCursor = IBMramdac640ShowCursor;
+    infoPtr->UseHWCursor = IBMramdac640UseHWCursor;
+}
diff --git a/xorg-server/hw/xfree86/ramdac/IBM.h b/xorg-server/hw/xfree86/ramdac/IBM.h
index 6fa18b219..986be2f48 100644
--- a/xorg-server/hw/xfree86/ramdac/IBM.h
+++ b/xorg-server/hw/xfree86/ramdac/IBM.h
@@ -1,19 +1,54 @@
 
 #include <xf86RamDac.h>
 
-extern _X_EXPORT RamDacHelperRecPtr IBMramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs);
-extern _X_EXPORT void IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void IBMramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void IBMramdac526SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void IBMramdac640SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT unsigned long IBMramdac526CalculateMNPCForClock(unsigned long RefClock,
-    unsigned long ReqClock, char IsPixClock, unsigned long MinClock,
-    unsigned long MaxClock, unsigned long *rM, unsigned long *rN,
-    unsigned long *rP, unsigned long *rC);
-extern _X_EXPORT unsigned long IBMramdac640CalculateMNPCForClock(unsigned long RefClock,
-    unsigned long ReqClock, char IsPixClock, unsigned long MinClock,
-    unsigned long MaxClock, unsigned long *rM, unsigned long *rN,
-    unsigned long *rP, unsigned long *rC);
+extern _X_EXPORT RamDacHelperRecPtr IBMramdacProbe(ScrnInfoPtr pScrn,
+                                                   RamDacSupportedInfoRecPtr
+                                                   ramdacs);
+extern _X_EXPORT void IBMramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec,
+                                    RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void IBMramdacRestore(ScrnInfoPtr pScrn,
+                                       RamDacRecPtr RamDacRec,
+                                       RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void IBMramdac526SetBpp(ScrnInfoPtr pScrn,
+                                         RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void IBMramdac640SetBpp(ScrnInfoPtr pScrn,
+                                         RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT unsigned long IBMramdac526CalculateMNPCForClock(unsigned long
+                                                                 RefClock,
+                                                                 unsigned long
+                                                                 ReqClock,
+                                                                 char
+                                                                 IsPixClock,
+                                                                 unsigned long
+                                                                 MinClock,
+                                                                 unsigned long
+                                                                 MaxClock,
+                                                                 unsigned long
+                                                                 *rM,
+                                                                 unsigned long
+                                                                 *rN,
+                                                                 unsigned long
+                                                                 *rP,
+                                                                 unsigned long
+                                                                 *rC);
+extern _X_EXPORT unsigned long IBMramdac640CalculateMNPCForClock(unsigned long
+                                                                 RefClock,
+                                                                 unsigned long
+                                                                 ReqClock,
+                                                                 char
+                                                                 IsPixClock,
+                                                                 unsigned long
+                                                                 MinClock,
+                                                                 unsigned long
+                                                                 MaxClock,
+                                                                 unsigned long
+                                                                 *rM,
+                                                                 unsigned long
+                                                                 *rN,
+                                                                 unsigned long
+                                                                 *rP,
+                                                                 unsigned long
+                                                                 *rC);
 extern _X_EXPORT void IBMramdac526HWCursorInit(xf86CursorInfoPtr infoPtr);
 extern _X_EXPORT void IBMramdac640HWCursorInit(xf86CursorInfoPtr infoPtr);
 
@@ -46,7 +81,7 @@ extern _X_EXPORT IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void);
 #define IBMRGB_pwr_mgmt		0x05
 #define IBMRGB_dac_op		0x06
 #define IBMRGB_pal_ctrl		0x07
-#define IBMRGB_sysclk		0x08  /* not RGB525 */
+#define IBMRGB_sysclk		0x08    /* not RGB525 */
 #define IBMRGB_pix_fmt		0x0a
 #define IBMRGB_8bpp		0x0b
 #define IBMRGB_16bpp		0x0c
@@ -55,8 +90,8 @@ extern _X_EXPORT IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void);
 #define IBMRGB_pll_ctrl1	0x10
 #define IBMRGB_pll_ctrl2	0x11
 #define IBMRGB_pll_ref_div_fix	0x14
-#define IBMRGB_sysclk_ref_div	0x15  /* not RGB525 */
-#define IBMRGB_sysclk_vco_div	0x16  /* not RGB525 */
+#define IBMRGB_sysclk_ref_div	0x15    /* not RGB525 */
+#define IBMRGB_sysclk_vco_div	0x16    /* not RGB525 */
 /* #define IBMRGB_f0		0x20 */
 
 #define IBMRGB_sysclk_n		0x15
@@ -105,7 +140,7 @@ extern _X_EXPORT IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void);
 #define IBMRGB_misc1		0x70
 #define IBMRGB_misc2		0x71
 #define IBMRGB_misc3		0x72
-#define IBMRGB_misc4		0x73  /* not RGB525 */
+#define IBMRGB_misc4		0x73    /* not RGB525 */
 #define IBMRGB_key_control	0x78
 #define IBMRGB_dac_sense	0x82
 #define IBMRGB_misr_r		0x84
@@ -119,9 +154,7 @@ extern _X_EXPORT IBMramdac526SetBppProc *IBMramdac526SetBppWeak(void);
 #define IBMRGB_vram_mask_3	0x93
 #define IBMRGB_curs_array	0x100
 
-
-
-/* Constants rgb525.h */  
+/* Constants rgb525.h */
 
 /* RGB525_REVISION_LEVEL */
 #define RGB525_PRODUCT_REV_LEVEL        0xf0
diff --git a/xorg-server/hw/xfree86/ramdac/TI.c b/xorg-server/hw/xfree86/ramdac/TI.c
index f189fed25..393b774d4 100644
--- a/xorg-server/hw/xfree86/ramdac/TI.c
+++ b/xorg-server/hw/xfree86/ramdac/TI.c
@@ -1,717 +1,725 @@
-/*

- * Copyright 1998 by Alan Hourihane, Wigan, England.

- *

- * Permission to use, copy, modify, distribute, and sell this software and its

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Alan Hourihane not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Alan Hourihane makes no representations

- * about the suitability of this software for any purpose.  It is provided

- * "as is" without express or implied warranty.

- *

- * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

- * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR

- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

- * PERFORMANCE OF THIS SOFTWARE.

- *

- * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>

- *

- * Modified from IBM.c to support TI RAMDAC routines 

- *   by Jens Owen, <jens@tungstengraphics.com>.

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include "xf86.h"

-#include "xf86_OSproc.h"

-

-#include "xf86Cursor.h"

-

-#define INIT_TI_RAMDAC_INFO

-#include "TIPriv.h"

-#include "xf86RamDacPriv.h"

-

-/* The following values are in kHz */

-#define TI_MIN_VCO_FREQ  110000

-#define TI_MAX_VCO_FREQ  220000

-

-unsigned long

-TIramdacCalculateMNPForClock(

-    unsigned long RefClock,	/* In 100Hz units */

-    unsigned long ReqClock,	/* In 100Hz units */

-    char IsPixClock,	/* boolean, is this the pixel or the sys clock */

-    unsigned long MinClock,	/* Min VCO rating */

-    unsigned long MaxClock,	/* Max VCO rating */

-    unsigned long *rM,	/* M Out */

-    unsigned long *rN,	/* N Out */

-    unsigned long *rP 	/* Min P In, P Out */

-)

-{

-    unsigned long   n, p;

-    unsigned long   best_m = 0, best_n = 0;

-    double          VCO, IntRef = (double)RefClock;

-    double          m_err, inc_m, calc_m;

-    unsigned long   ActualClock;

-

-    /* Make sure that MinClock <= ReqClock <= MaxClock */

-    if ( ReqClock < MinClock)

-	ReqClock = MinClock;

-    if ( ReqClock > MaxClock )

-	ReqClock = MaxClock;

-

-    /*

-     * ActualClock = VCO / 2 ^ p

-     * Choose p so that TI_MIN_VCO_FREQ <= VCO <= TI_MAX_VCO_FREQ

-     * Note that since TI_MAX_VCO_FREQ = 2 * TI_MIN_VCO_FREQ

-     * we don't have to bother checking for this maximum limit.

-     */

-    VCO = (double)ReqClock;

-    for ( p = 0; p < 3 && VCO < TI_MIN_VCO_FREQ; ( p )++ )

-	 VCO *= 2.0;

-

-    /*

-     * We avoid doing multiplications by ( 65 - n ),

-     * and add an increment instead - this keeps any error small.

-     */

-    inc_m = VCO / ( IntRef * 8.0 );

-

-    /* Initial value of calc_m for the loop */

-    calc_m = inc_m + inc_m + inc_m;

-

-    /* Initial amount of error for an integer - impossibly large */

-    m_err = 2.0;

-

-    /* Search for the closest INTEGER value of ( 65 - m ) */

-    for ( n = 3; n <= 25; ( n )++, calc_m += inc_m ) {

-

-	/* Ignore values of ( 65 - m ) which we can't use */

-	if ( calc_m < 3.0 || calc_m > 64.0 )

-	    continue;

-

-	/*

-	 * Pick the closest INTEGER (has smallest fractional part).

-	 * The optimizer should clean this up for us.

-	 */

-	if (( calc_m - ( int ) calc_m ) < m_err ) {

-	    m_err = calc_m - ( int ) calc_m;

-	    best_m = ( int ) calc_m;

-	    best_n = n;

-	}

-    }

-

-    /* 65 - ( 65 - x ) = x */

-    *rM = 65 - best_m;

-    *rN = 65 - best_n;

-    *rP = p;

-

-    /* Now all the calculations can be completed */

-    VCO = 8.0 * IntRef * best_m / best_n;

-    ActualClock = VCO / ( 1 << p );

-

-    DebugF( "f_out=%ld f_vco=%.1f n=%d m=%d p=%d\n",

-	    ActualClock, VCO, *rN, *rM, *rP);

-

-    return ActualClock;

-}

-

-void

-TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,

-				   RamDacRegRecPtr ramdacReg)

-{

-    int i;

-    unsigned long status;

-

-    /* Here we pass a short, so that we can evaluate a mask too

-     * So that the mask is the high byte and the data the low byte

-     * Order is important

-     */

-    TIRESTORE(TIDAC_latch_ctrl);

-    TIRESTORE(TIDAC_true_color_ctrl);

-    TIRESTORE(TIDAC_multiplex_ctrl);

-    TIRESTORE(TIDAC_clock_select);

-    TIRESTORE(TIDAC_palette_page);

-    TIRESTORE(TIDAC_general_ctrl);

-    TIRESTORE(TIDAC_misc_ctrl);

-	    /* 0x2A & 0x2B are reserved */

-    TIRESTORE(TIDAC_key_over_low);

-    TIRESTORE(TIDAC_key_over_high);

-    TIRESTORE(TIDAC_key_red_low);

-    TIRESTORE(TIDAC_key_red_high);

-    TIRESTORE(TIDAC_key_green_low);

-    TIRESTORE(TIDAC_key_green_high);

-    TIRESTORE(TIDAC_key_blue_low);

-    TIRESTORE(TIDAC_key_blue_high);

-    TIRESTORE(TIDAC_key_ctrl);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x30);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_clock_ctrl, 0, 0x38);

-    TIRESTORE(TIDAC_clock_ctrl);

-    TIRESTORE(TIDAC_sense_test);

-    TIRESTORE(TIDAC_ind_curs_ctrl);

-

-    /* only restore clocks if they were valid to begin with */

-

-    if (ramdacReg->DacRegs[TIDAC_PIXEL_VALID]) {

-    /* Reset pixel clock */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0, 0x3c);

-

-    /* Restore N, M & P values for pixel clocks */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

-					ramdacReg->DacRegs[TIDAC_PIXEL_N]);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

-					ramdacReg->DacRegs[TIDAC_PIXEL_M]);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_pixel_data, 0,

-					ramdacReg->DacRegs[TIDAC_PIXEL_P]);

-

-    /* wait for pixel clock to lock */

-    i = 1000000;

-    do {

-	status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

-    } while ((!(status & 0x40)) && (--i));

-    if (!(status & 0x40)) {

-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 

-			"Pixel clock setup timed out\n");

-	return;

-    }

-    }

-

-    if (ramdacReg->DacRegs[TIDAC_LOOP_VALID]) {

-    /* Reset loop clock */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0, 0x70);

-

-    /* Restore N, M & P values for pixel clocks */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

-					ramdacReg->DacRegs[TIDAC_LOOP_N]);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

-					ramdacReg->DacRegs[TIDAC_LOOP_M]);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_loop_data, 0,

-					ramdacReg->DacRegs[TIDAC_LOOP_P]);

-

-    /* wait for loop clock to lock */

-    i = 1000000;

-    do {

-        status = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

-    } while ((!(status & 0x40)) && (--i));

-    if (!(status & 0x40)) {

-	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 

-			"Loop clock setup timed out\n");

-	    return;

-    }

-    }

-

-    /* restore palette */

-    (*ramdacPtr->WriteAddress)(pScrn, 0);

-#ifndef NOT_DONE

-    for (i=0;i<768;i++)

-	(*ramdacPtr->WriteData)(pScrn, ramdacReg->DAC[i]);

-#else

-	(*ramdacPtr->WriteData)(pScrn, 0);

-	(*ramdacPtr->WriteData)(pScrn, 0);

-	(*ramdacPtr->WriteData)(pScrn, 0);

-    for (i=0;i<765;i++)

-	(*ramdacPtr->WriteData)(pScrn, 0xff);

-#endif

-}

-

-void

-TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr, 

-				RamDacRegRecPtr ramdacReg)

-{

-    int i;

-

-    (*ramdacPtr->ReadAddress)(pScrn, 0);

-    for (i=0;i<768;i++)

-	ramdacReg->DAC[i] = (*ramdacPtr->ReadData)(pScrn);

-

-    /* Read back N,M and P values for pixel clock */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

-    ramdacReg->DacRegs[TIDAC_PIXEL_N] = 

-			(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);

-    ramdacReg->DacRegs[TIDAC_PIXEL_M] = 

-		    	(*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

-    ramdacReg->DacRegs[TIDAC_PIXEL_P] = 

-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_pixel_data);

-

-    /* Read back N,M and P values for loop clock */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0);

-    ramdacReg->DacRegs[TIDAC_LOOP_N] = 

-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x11);

-    ramdacReg->DacRegs[TIDAC_LOOP_M] = 

-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_pll_addr, 0, 0x22);

-    ramdacReg->DacRegs[TIDAC_LOOP_P] = 

-		    (*ramdacPtr->ReadDAC)(pScrn, TIDAC_pll_loop_data);

-

-    /* Order is important */

-    TISAVE(TIDAC_latch_ctrl);

-    TISAVE(TIDAC_true_color_ctrl);

-    TISAVE(TIDAC_multiplex_ctrl);

-    TISAVE(TIDAC_clock_select);

-    TISAVE(TIDAC_palette_page);

-    TISAVE(TIDAC_general_ctrl);

-    TISAVE(TIDAC_misc_ctrl);

-	    /* 0x2A & 0x2B are reserved */

-    TISAVE(TIDAC_key_over_low);

-    TISAVE(TIDAC_key_over_high);

-    TISAVE(TIDAC_key_red_low);

-    TISAVE(TIDAC_key_red_high);

-    TISAVE(TIDAC_key_green_low);

-    TISAVE(TIDAC_key_green_high);

-    TISAVE(TIDAC_key_blue_low);

-    TISAVE(TIDAC_key_blue_high);

-    TISAVE(TIDAC_key_ctrl);

-    TISAVE(TIDAC_clock_ctrl);

-    TISAVE(TIDAC_sense_test);

-    TISAVE(TIDAC_ind_curs_ctrl);

-}

-

-RamDacHelperRecPtr

-TIramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-    RamDacHelperRecPtr ramdacHelperPtr = NULL;

-    Bool RamDacIsSupported = FALSE;

-    int TIramdac_ID = -1;

-    int i;

-    unsigned char id, rev, rev2, id2;

-

-    /* read ID and revision */

-    rev = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);

-    id = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);

-

-    /* check if ID and revision are read only */

-    (*ramdacPtr->WriteDAC)(pScrn, ~rev, 0, TIDAC_rev);

-    (*ramdacPtr->WriteDAC)(pScrn, ~id, 0, TIDAC_id);

-    rev2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_rev);

-    id2 = (*ramdacPtr->ReadDAC)(pScrn, TIDAC_id);

-

-    switch (id) {

-	case TIDAC_TVP_3030_ID:

-		if (id == id2 && rev == rev2)  /* check for READ ONLY */

-		    TIramdac_ID = TI3030_RAMDAC;

-		break;

-	case TIDAC_TVP_3026_ID:

-		if (id == id2 && rev == rev2)  /* check for READ ONLY */

-		    TIramdac_ID = TI3026_RAMDAC;

-		break;

-    }

-

-    (*ramdacPtr->WriteDAC)(pScrn, rev, 0, TIDAC_rev);

-    (*ramdacPtr->WriteDAC)(pScrn, id, 0, TIDAC_id);

-

-    if (TIramdac_ID == -1) {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"Cannot determine TI RAMDAC type, aborting\n");

-	return NULL;

-    } else {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"Attached RAMDAC is %s\n", TIramdacDeviceInfo[TIramdac_ID&0xFFFF].DeviceName);

-    }

-

-    for (i=0;ramdacs[i].token != -1;i++) {

-	if (ramdacs[i].token == TIramdac_ID)

-	    RamDacIsSupported = TRUE;

-    }

-

-    if (!RamDacIsSupported) {

-        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, 

-		"This TI RAMDAC is NOT supported by this driver, aborting\n");

-	return NULL;

-    }

-

-    ramdacHelperPtr = RamDacHelperCreateInfoRec();

-    switch (TIramdac_ID) {

-	case TI3030_RAMDAC:

- 	    ramdacHelperPtr->SetBpp = TIramdac3030SetBpp;

-    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;

-	    break;

-	case TI3026_RAMDAC:

- 	    ramdacHelperPtr->SetBpp = TIramdac3026SetBpp;

-    	    ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;

-	    break;

-    }

-    ramdacPtr->RamDacType = TIramdac_ID;

-    ramdacHelperPtr->RamDacType = TIramdac_ID;

-    ramdacHelperPtr->Save = TIramdacSave;

-    ramdacHelperPtr->Restore = TIramdacRestore;

-

-    return ramdacHelperPtr;

-}

-

-void

-TIramdac3026SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

-{

-    switch (pScrn->bitsPerPixel) {

-    case 32:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5c;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;

-	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

-	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;

-	}

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 24:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 16:

-	/* order is important */

-#if 0

-	/* Matrox driver uses this */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;

-#else

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-#endif

-	if (pScrn->depth == 16) {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;

-	} else {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;

-	}

-#if 0

-	/* Matrox driver uses this */

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

-#else

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x54;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-#endif

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 8:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4c;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    }

-}

-

-void

-TIramdac3030SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)

-{

-    switch (pScrn->bitsPerPixel) {

-    case 32:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5D;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;

-	    ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;

-	    ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;

-	}

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 24:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 16:

-	/* order is important */

-#if 0

-	/* Matrox driver uses this */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;

-#else

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-#endif

-	if (pScrn->depth == 16) {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;

-	} else {

-	    ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;

-	}

-#if 0

-	/* Matrox driver uses this */

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;

-#else

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x55;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x85;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-#endif

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    case 8:

-	/* order is important */

-	ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;

-	ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;

-	ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4d;

-	ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;

-	ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;

-	ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;

-	ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;

-	/* 0x2A & 0x2B are reserved */

-	ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;

-	ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;

-	ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;

-	ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;

-	ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;

-	break;

-    }

-}

-

-static void 

-TIramdacShowCursor(ScrnInfoPtr pScrn)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-    /* Enable cursor - X11 mode */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x03);

-}

-

-static void

-TIramdacHideCursor(ScrnInfoPtr pScrn)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-    /* Disable cursor - X11 mode */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00);

-}

-

-static void

-TIramdacSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-    x += 64;

-    y += 64;

-

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XLOW,  0, x & 0xff);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_XHIGH, 0, (x >> 8) & 0x0f);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YLOW,  0, y & 0xff);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_YHIGH, 0, (y >> 8) & 0x0f);

-}

-

-static void

-TIramdacSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-

-    /* Background color */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 1);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x00ff0000) >> 16));

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((bg&0x0000ff00) >>  8));

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (bg&0x000000ff)       );

-

-    /* Foreground color */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_WRITE_ADDR, 0, 2);

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x00ff0000) >> 16));

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0, ((fg&0x0000ff00) >>  8));

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_COLOR, 0,  (fg&0x000000ff)       );

-}

-

-static void 

-TIramdacLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)

-{

-    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);

-    int i = 1024;

-

-    /* reset A9,A8 */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_ind_curs_ctrl, 0, 0x00); 

-    /* reset cursor RAM load address A7..A0 */

-    (*ramdacPtr->WriteDAC)(pScrn, TIDAC_INDEX, 0x00, 0x00); 

- 

-    while(i--) {

-	/* NOT_DONE: might need a delay here */

-	(*ramdacPtr->WriteDAC)(pScrn, TIDAC_CURS_RAM_DATA, 0, *(src++));

-    }

-}

-

-static Bool 

-TIramdacUseHWCursor(ScreenPtr pScr, CursorPtr pCurs)

-{

-    return TRUE;

-}

-

-void

-TIramdacHWCursorInit(xf86CursorInfoPtr infoPtr)

-{

-    infoPtr->MaxWidth = 64;

-    infoPtr->MaxHeight = 64;

-    infoPtr->Flags = HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |

-		     HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |

-		     HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;

-    infoPtr->SetCursorColors = TIramdacSetCursorColors;

-    infoPtr->SetCursorPosition = TIramdacSetCursorPosition;

-    infoPtr->LoadCursorImage = TIramdacLoadCursorImage;

-    infoPtr->HideCursor = TIramdacHideCursor;

-    infoPtr->ShowCursor = TIramdacShowCursor;

-    infoPtr->UseHWCursor = TIramdacUseHWCursor;

-}

-

-void TIramdacLoadPalette(

-    ScrnInfoPtr pScrn, 

-    int numColors, 

-    int *indices,

-    LOCO *colors,

-    VisualPtr pVisual

-){

-    RamDacRecPtr hwp = RAMDACSCRPTR(pScrn);

-    int i, index, shift;

-

-    if (pScrn->depth == 16) {

-    for(i = 0; i < numColors; i++) {

-	index = indices[i];

-    	(*hwp->WriteAddress)(pScrn, index << 2);

-	(*hwp->WriteData)(pScrn, colors[index >> 1].red);

-	(*hwp->WriteData)(pScrn, colors[index].green);

-	(*hwp->WriteData)(pScrn, colors[index >> 1].blue);

-

-	if(index <= 31) {

-	    (*hwp->WriteAddress)(pScrn, index << 3);

-	    (*hwp->WriteData)(pScrn, colors[index].red);

-	    (*hwp->WriteData)(pScrn, colors[(index << 1) + 1].green);

-	    (*hwp->WriteData)(pScrn, colors[index].blue);

-	}

-    }

-} else {

-    shift = (pScrn->depth == 15) ? 3 : 0;

-

-    for(i = 0; i < numColors; i++) {

-	index = indices[i];

-    	(*hwp->WriteAddress)(pScrn, index << shift);

-	(*hwp->WriteData)(pScrn, colors[index].red);

-	(*hwp->WriteData)(pScrn, colors[index].green);

-	(*hwp->WriteData)(pScrn, colors[index].blue);

-    }

-}

-}

-

-TIramdacLoadPaletteProc *TIramdacLoadPaletteWeak(void) {

-    return TIramdacLoadPalette;

-}

+/*
+ * Copyright 1998 by Alan Hourihane, Wigan, England.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Alan Hourihane not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Alan Hourihane makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
+ *
+ * Modified from IBM.c to support TI RAMDAC routines 
+ *   by Jens Owen, <jens@tungstengraphics.com>.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+
+#include "xf86Cursor.h"
+
+#define INIT_TI_RAMDAC_INFO
+#include "TIPriv.h"
+#include "xf86RamDacPriv.h"
+
+/* The following values are in kHz */
+#define TI_MIN_VCO_FREQ  110000
+#define TI_MAX_VCO_FREQ  220000
+
+unsigned long
+TIramdacCalculateMNPForClock(unsigned long RefClock,    /* In 100Hz units */
+                             unsigned long ReqClock,    /* In 100Hz units */
+                             char IsPixClock,   /* boolean, is this the pixel or the sys clock */
+                             unsigned long MinClock,    /* Min VCO rating */
+                             unsigned long MaxClock,    /* Max VCO rating */
+                             unsigned long *rM, /* M Out */
+                             unsigned long *rN, /* N Out */
+                             unsigned long *rP  /* Min P In, P Out */
+    )
+{
+    unsigned long n, p;
+    unsigned long best_m = 0, best_n = 0;
+    double VCO, IntRef = (double) RefClock;
+    double m_err, inc_m, calc_m;
+    unsigned long ActualClock;
+
+    /* Make sure that MinClock <= ReqClock <= MaxClock */
+    if (ReqClock < MinClock)
+        ReqClock = MinClock;
+    if (ReqClock > MaxClock)
+        ReqClock = MaxClock;
+
+    /*
+     * ActualClock = VCO / 2 ^ p
+     * Choose p so that TI_MIN_VCO_FREQ <= VCO <= TI_MAX_VCO_FREQ
+     * Note that since TI_MAX_VCO_FREQ = 2 * TI_MIN_VCO_FREQ
+     * we don't have to bother checking for this maximum limit.
+     */
+    VCO = (double) ReqClock;
+    for (p = 0; p < 3 && VCO < TI_MIN_VCO_FREQ; (p)++)
+        VCO *= 2.0;
+
+    /*
+     * We avoid doing multiplications by ( 65 - n ),
+     * and add an increment instead - this keeps any error small.
+     */
+    inc_m = VCO / (IntRef * 8.0);
+
+    /* Initial value of calc_m for the loop */
+    calc_m = inc_m + inc_m + inc_m;
+
+    /* Initial amount of error for an integer - impossibly large */
+    m_err = 2.0;
+
+    /* Search for the closest INTEGER value of ( 65 - m ) */
+    for (n = 3; n <= 25; (n)++, calc_m += inc_m) {
+
+        /* Ignore values of ( 65 - m ) which we can't use */
+        if (calc_m < 3.0 || calc_m > 64.0)
+            continue;
+
+        /*
+         * Pick the closest INTEGER (has smallest fractional part).
+         * The optimizer should clean this up for us.
+         */
+        if ((calc_m - (int) calc_m) < m_err) {
+            m_err = calc_m - (int) calc_m;
+            best_m = (int) calc_m;
+            best_n = n;
+        }
+    }
+
+    /* 65 - ( 65 - x ) = x */
+    *rM = 65 - best_m;
+    *rN = 65 - best_n;
+    *rP = p;
+
+    /* Now all the calculations can be completed */
+    VCO = 8.0 * IntRef * best_m / best_n;
+    ActualClock = VCO / (1 << p);
+
+    DebugF("f_out=%ld f_vco=%.1f n=%d m=%d p=%d\n",
+           ActualClock, VCO, *rN, *rM, *rP);
+
+    return ActualClock;
+}
+
+void
+TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
+                RamDacRegRecPtr ramdacReg)
+{
+    int i;
+    unsigned long status;
+
+    /* Here we pass a short, so that we can evaluate a mask too
+     * So that the mask is the high byte and the data the low byte
+     * Order is important
+     */
+    TIRESTORE(TIDAC_latch_ctrl);
+    TIRESTORE(TIDAC_true_color_ctrl);
+    TIRESTORE(TIDAC_multiplex_ctrl);
+    TIRESTORE(TIDAC_clock_select);
+    TIRESTORE(TIDAC_palette_page);
+    TIRESTORE(TIDAC_general_ctrl);
+    TIRESTORE(TIDAC_misc_ctrl);
+    /* 0x2A & 0x2B are reserved */
+    TIRESTORE(TIDAC_key_over_low);
+    TIRESTORE(TIDAC_key_over_high);
+    TIRESTORE(TIDAC_key_red_low);
+    TIRESTORE(TIDAC_key_red_high);
+    TIRESTORE(TIDAC_key_green_low);
+    TIRESTORE(TIDAC_key_green_high);
+    TIRESTORE(TIDAC_key_blue_low);
+    TIRESTORE(TIDAC_key_blue_high);
+    TIRESTORE(TIDAC_key_ctrl);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_clock_ctrl, 0, 0x30);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_clock_ctrl, 0, 0x38);
+    TIRESTORE(TIDAC_clock_ctrl);
+    TIRESTORE(TIDAC_sense_test);
+    TIRESTORE(TIDAC_ind_curs_ctrl);
+
+    /* only restore clocks if they were valid to begin with */
+
+    if (ramdacReg->DacRegs[TIDAC_PIXEL_VALID]) {
+        /* Reset pixel clock */
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x22);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_pixel_data, 0, 0x3c);
+
+        /* Restore N, M & P values for pixel clocks */
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_pixel_data, 0,
+                                ramdacReg->DacRegs[TIDAC_PIXEL_N]);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_pixel_data, 0,
+                                ramdacReg->DacRegs[TIDAC_PIXEL_M]);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_pixel_data, 0,
+                                ramdacReg->DacRegs[TIDAC_PIXEL_P]);
+
+        /* wait for pixel clock to lock */
+        i = 1000000;
+        do {
+            status = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_pixel_data);
+        } while ((!(status & 0x40)) && (--i));
+        if (!(status & 0x40)) {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "Pixel clock setup timed out\n");
+            return;
+        }
+    }
+
+    if (ramdacReg->DacRegs[TIDAC_LOOP_VALID]) {
+        /* Reset loop clock */
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x22);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_loop_data, 0, 0x70);
+
+        /* Restore N, M & P values for pixel clocks */
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_loop_data, 0,
+                                ramdacReg->DacRegs[TIDAC_LOOP_N]);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_loop_data, 0,
+                                ramdacReg->DacRegs[TIDAC_LOOP_M]);
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_loop_data, 0,
+                                ramdacReg->DacRegs[TIDAC_LOOP_P]);
+
+        /* wait for loop clock to lock */
+        i = 1000000;
+        do {
+            status = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_loop_data);
+        } while ((!(status & 0x40)) && (--i));
+        if (!(status & 0x40)) {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "Loop clock setup timed out\n");
+            return;
+        }
+    }
+
+    /* restore palette */
+    (*ramdacPtr->WriteAddress) (pScrn, 0);
+#ifndef NOT_DONE
+    for (i = 0; i < 768; i++)
+        (*ramdacPtr->WriteData) (pScrn, ramdacReg->DAC[i]);
+#else
+    (*ramdacPtr->WriteData) (pScrn, 0);
+    (*ramdacPtr->WriteData) (pScrn, 0);
+    (*ramdacPtr->WriteData) (pScrn, 0);
+    for (i = 0; i < 765; i++)
+        (*ramdacPtr->WriteData) (pScrn, 0xff);
+#endif
+}
+
+void
+TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr ramdacPtr,
+             RamDacRegRecPtr ramdacReg)
+{
+    int i;
+
+    (*ramdacPtr->ReadAddress) (pScrn, 0);
+    for (i = 0; i < 768; i++)
+        ramdacReg->DAC[i] = (*ramdacPtr->ReadData) (pScrn);
+
+    /* Read back N,M and P values for pixel clock */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0);
+    ramdacReg->DacRegs[TIDAC_PIXEL_N] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_pixel_data);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x11);
+    ramdacReg->DacRegs[TIDAC_PIXEL_M] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_pixel_data);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x22);
+    ramdacReg->DacRegs[TIDAC_PIXEL_P] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_pixel_data);
+
+    /* Read back N,M and P values for loop clock */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0);
+    ramdacReg->DacRegs[TIDAC_LOOP_N] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_loop_data);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x11);
+    ramdacReg->DacRegs[TIDAC_LOOP_M] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_loop_data);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_pll_addr, 0, 0x22);
+    ramdacReg->DacRegs[TIDAC_LOOP_P] =
+        (*ramdacPtr->ReadDAC) (pScrn, TIDAC_pll_loop_data);
+
+    /* Order is important */
+    TISAVE(TIDAC_latch_ctrl);
+    TISAVE(TIDAC_true_color_ctrl);
+    TISAVE(TIDAC_multiplex_ctrl);
+    TISAVE(TIDAC_clock_select);
+    TISAVE(TIDAC_palette_page);
+    TISAVE(TIDAC_general_ctrl);
+    TISAVE(TIDAC_misc_ctrl);
+    /* 0x2A & 0x2B are reserved */
+    TISAVE(TIDAC_key_over_low);
+    TISAVE(TIDAC_key_over_high);
+    TISAVE(TIDAC_key_red_low);
+    TISAVE(TIDAC_key_red_high);
+    TISAVE(TIDAC_key_green_low);
+    TISAVE(TIDAC_key_green_high);
+    TISAVE(TIDAC_key_blue_low);
+    TISAVE(TIDAC_key_blue_high);
+    TISAVE(TIDAC_key_ctrl);
+    TISAVE(TIDAC_clock_ctrl);
+    TISAVE(TIDAC_sense_test);
+    TISAVE(TIDAC_ind_curs_ctrl);
+}
+
+RamDacHelperRecPtr
+TIramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+    RamDacHelperRecPtr ramdacHelperPtr = NULL;
+    Bool RamDacIsSupported = FALSE;
+    int TIramdac_ID = -1;
+    int i;
+    unsigned char id, rev, rev2, id2;
+
+    /* read ID and revision */
+    rev = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_rev);
+    id = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_id);
+
+    /* check if ID and revision are read only */
+    (*ramdacPtr->WriteDAC) (pScrn, ~rev, 0, TIDAC_rev);
+    (*ramdacPtr->WriteDAC) (pScrn, ~id, 0, TIDAC_id);
+    rev2 = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_rev);
+    id2 = (*ramdacPtr->ReadDAC) (pScrn, TIDAC_id);
+
+    switch (id) {
+    case TIDAC_TVP_3030_ID:
+        if (id == id2 && rev == rev2)   /* check for READ ONLY */
+            TIramdac_ID = TI3030_RAMDAC;
+        break;
+    case TIDAC_TVP_3026_ID:
+        if (id == id2 && rev == rev2)   /* check for READ ONLY */
+            TIramdac_ID = TI3026_RAMDAC;
+        break;
+    }
+
+    (*ramdacPtr->WriteDAC) (pScrn, rev, 0, TIDAC_rev);
+    (*ramdacPtr->WriteDAC) (pScrn, id, 0, TIDAC_id);
+
+    if (TIramdac_ID == -1) {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Cannot determine TI RAMDAC type, aborting\n");
+        return NULL;
+    }
+    else {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "Attached RAMDAC is %s\n",
+                   TIramdacDeviceInfo[TIramdac_ID & 0xFFFF].DeviceName);
+    }
+
+    for (i = 0; ramdacs[i].token != -1; i++) {
+        if (ramdacs[i].token == TIramdac_ID)
+            RamDacIsSupported = TRUE;
+    }
+
+    if (!RamDacIsSupported) {
+        xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+                   "This TI RAMDAC is NOT supported by this driver, aborting\n");
+        return NULL;
+    }
+
+    ramdacHelperPtr = RamDacHelperCreateInfoRec();
+    switch (TIramdac_ID) {
+    case TI3030_RAMDAC:
+        ramdacHelperPtr->SetBpp = TIramdac3030SetBpp;
+        ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;
+        break;
+    case TI3026_RAMDAC:
+        ramdacHelperPtr->SetBpp = TIramdac3026SetBpp;
+        ramdacHelperPtr->HWCursorInit = TIramdacHWCursorInit;
+        break;
+    }
+    ramdacPtr->RamDacType = TIramdac_ID;
+    ramdacHelperPtr->RamDacType = TIramdac_ID;
+    ramdacHelperPtr->Save = TIramdacSave;
+    ramdacHelperPtr->Restore = TIramdacRestore;
+
+    return ramdacHelperPtr;
+}
+
+void
+TIramdac3026SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
+{
+    switch (pScrn->bitsPerPixel) {
+    case 32:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5c;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;
+            ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
+            ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;
+        }
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 24:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 16:
+        /* order is important */
+#if 0
+        /* Matrox driver uses this */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;
+#else
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+#endif
+        if (pScrn->depth == 16) {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;
+        }
+        else {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;
+        }
+#if 0
+        /* Matrox driver uses this */
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
+#else
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x54;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+#endif
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 8:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4c;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    }
+}
+
+void
+TIramdac3030SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg)
+{
+    switch (pScrn->bitsPerPixel) {
+    case 32:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x46;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x5D;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x06;
+            ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x3C;
+            ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x01;
+        }
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 24:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x56;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x58;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x25;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 16:
+        /* order is important */
+#if 0
+        /* Matrox driver uses this */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x07;
+#else
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+#endif
+        if (pScrn->depth == 16) {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x45;
+        }
+        else {
+            ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x44;
+        }
+#if 0
+        /* Matrox driver uses this */
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x50;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x15;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x00;
+#else
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x55;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x85;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+#endif
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x2C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    case 8:
+        /* order is important */
+        ramdacReg->DacRegs[TIDAC_latch_ctrl] = 0x06;
+        ramdacReg->DacRegs[TIDAC_true_color_ctrl] = 0x80;
+        ramdacReg->DacRegs[TIDAC_multiplex_ctrl] = 0x4d;
+        ramdacReg->DacRegs[TIDAC_clock_select] = 0x05;
+        ramdacReg->DacRegs[TIDAC_palette_page] = 0x00;
+        ramdacReg->DacRegs[TIDAC_general_ctrl] = 0x10;
+        ramdacReg->DacRegs[TIDAC_misc_ctrl] = 0x1C;
+        /* 0x2A & 0x2B are reserved */
+        ramdacReg->DacRegs[TIDAC_key_over_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_over_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_red_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_low] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_green_high] = 0xFF;
+        ramdacReg->DacRegs[TIDAC_key_blue_low] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_blue_high] = 0x00;
+        ramdacReg->DacRegs[TIDAC_key_ctrl] = 0x00;
+        ramdacReg->DacRegs[TIDAC_sense_test] = 0x00;
+        ramdacReg->DacRegs[TIDAC_ind_curs_ctrl] = 0x00;
+        break;
+    }
+}
+
+static void
+TIramdacShowCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Enable cursor - X11 mode */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_ind_curs_ctrl, 0, 0x03);
+}
+
+static void
+TIramdacHideCursor(ScrnInfoPtr pScrn)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Disable cursor - X11 mode */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_ind_curs_ctrl, 0, 0x00);
+}
+
+static void
+TIramdacSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    x += 64;
+    y += 64;
+
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_XLOW, 0, x & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_XHIGH, 0, (x >> 8) & 0x0f);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_YLOW, 0, y & 0xff);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_YHIGH, 0, (y >> 8) & 0x0f);
+}
+
+static void
+TIramdacSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+
+    /* Background color */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_WRITE_ADDR, 0, 1);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0,
+                            ((bg & 0x00ff0000) >> 16));
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0,
+                            ((bg & 0x0000ff00) >> 8));
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0, (bg & 0x000000ff));
+
+    /* Foreground color */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_WRITE_ADDR, 0, 2);
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0,
+                            ((fg & 0x00ff0000) >> 16));
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0,
+                            ((fg & 0x0000ff00) >> 8));
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_COLOR, 0, (fg & 0x000000ff));
+}
+
+static void
+TIramdacLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
+{
+    RamDacRecPtr ramdacPtr = RAMDACSCRPTR(pScrn);
+    int i = 1024;
+
+    /* reset A9,A8 */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_ind_curs_ctrl, 0, 0x00);
+    /* reset cursor RAM load address A7..A0 */
+    (*ramdacPtr->WriteDAC) (pScrn, TIDAC_INDEX, 0x00, 0x00);
+
+    while (i--) {
+        /* NOT_DONE: might need a delay here */
+        (*ramdacPtr->WriteDAC) (pScrn, TIDAC_CURS_RAM_DATA, 0, *(src++));
+    }
+}
+
+static Bool
+TIramdacUseHWCursor(ScreenPtr pScr, CursorPtr pCurs)
+{
+    return TRUE;
+}
+
+void
+TIramdacHWCursorInit(xf86CursorInfoPtr infoPtr)
+{
+    infoPtr->MaxWidth = 64;
+    infoPtr->MaxHeight = 64;
+    infoPtr->Flags = HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
+        HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
+        HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;
+    infoPtr->SetCursorColors = TIramdacSetCursorColors;
+    infoPtr->SetCursorPosition = TIramdacSetCursorPosition;
+    infoPtr->LoadCursorImage = TIramdacLoadCursorImage;
+    infoPtr->HideCursor = TIramdacHideCursor;
+    infoPtr->ShowCursor = TIramdacShowCursor;
+    infoPtr->UseHWCursor = TIramdacUseHWCursor;
+}
+
+void
+TIramdacLoadPalette(ScrnInfoPtr pScrn,
+                    int numColors,
+                    int *indices, LOCO * colors, VisualPtr pVisual)
+{
+    RamDacRecPtr hwp = RAMDACSCRPTR(pScrn);
+    int i, index, shift;
+
+    if (pScrn->depth == 16) {
+        for (i = 0; i < numColors; i++) {
+            index = indices[i];
+            (*hwp->WriteAddress) (pScrn, index << 2);
+            (*hwp->WriteData) (pScrn, colors[index >> 1].red);
+            (*hwp->WriteData) (pScrn, colors[index].green);
+            (*hwp->WriteData) (pScrn, colors[index >> 1].blue);
+
+            if (index <= 31) {
+                (*hwp->WriteAddress) (pScrn, index << 3);
+                (*hwp->WriteData) (pScrn, colors[index].red);
+                (*hwp->WriteData) (pScrn, colors[(index << 1) + 1].green);
+                (*hwp->WriteData) (pScrn, colors[index].blue);
+            }
+        }
+    }
+    else {
+        shift = (pScrn->depth == 15) ? 3 : 0;
+
+        for (i = 0; i < numColors; i++) {
+            index = indices[i];
+            (*hwp->WriteAddress) (pScrn, index << shift);
+            (*hwp->WriteData) (pScrn, colors[index].red);
+            (*hwp->WriteData) (pScrn, colors[index].green);
+            (*hwp->WriteData) (pScrn, colors[index].blue);
+        }
+    }
+}
+
+TIramdacLoadPaletteProc *
+TIramdacLoadPaletteWeak(void)
+{
+    return TIramdacLoadPalette;
+}
diff --git a/xorg-server/hw/xfree86/ramdac/TI.h b/xorg-server/hw/xfree86/ramdac/TI.h
index f5499f903..3969ee71d 100644
--- a/xorg-server/hw/xfree86/ramdac/TI.h
+++ b/xorg-server/hw/xfree86/ramdac/TI.h
@@ -1,21 +1,36 @@
 
 #include <xf86RamDac.h>
 
-extern _X_EXPORT unsigned long TIramdacCalculateMNPForClock(unsigned long RefClock,
-    unsigned long ReqClock, char IsPixClock, unsigned long MinClock,
-    unsigned long MaxClock, unsigned long *rM, unsigned long *rN,
-    unsigned long *rP);
-extern _X_EXPORT RamDacHelperRecPtr TIramdacProbe(ScrnInfoPtr pScrn, RamDacSupportedInfoRecPtr ramdacs);
-extern _X_EXPORT void TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void TIramdac3026SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRegRec);
-extern _X_EXPORT void TIramdac3030SetBpp(ScrnInfoPtr pScrn, RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT unsigned long TIramdacCalculateMNPForClock(unsigned long
+                                                            RefClock,
+                                                            unsigned long
+                                                            ReqClock,
+                                                            char IsPixClock,
+                                                            unsigned long
+                                                            MinClock,
+                                                            unsigned long
+                                                            MaxClock,
+                                                            unsigned long *rM,
+                                                            unsigned long *rN,
+                                                            unsigned long *rP);
+extern _X_EXPORT RamDacHelperRecPtr TIramdacProbe(ScrnInfoPtr pScrn,
+                                                  RamDacSupportedInfoRecPtr
+                                                  ramdacs);
+extern _X_EXPORT void TIramdacSave(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec,
+                                   RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void TIramdacRestore(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec,
+                                      RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void TIramdac3026SetBpp(ScrnInfoPtr pScrn,
+                                         RamDacRegRecPtr RamDacRegRec);
+extern _X_EXPORT void TIramdac3030SetBpp(ScrnInfoPtr pScrn,
+                                         RamDacRegRecPtr RamDacRegRec);
 extern _X_EXPORT void TIramdacHWCursorInit(xf86CursorInfoPtr infoPtr);
-extern _X_EXPORT void TIramdacLoadPalette( ScrnInfoPtr pScrn, int numColors, int *indices,
-    LOCO *colors, VisualPtr pVisual);
+extern _X_EXPORT void TIramdacLoadPalette(ScrnInfoPtr pScrn, int numColors,
+                                          int *indices, LOCO * colors,
+                                          VisualPtr pVisual);
 
 typedef void TIramdacLoadPaletteProc(ScrnInfoPtr, int, int *, LOCO *,
-    VisualPtr);
+                                     VisualPtr);
 extern _X_EXPORT TIramdacLoadPaletteProc *TIramdacLoadPaletteWeak(void);
 
 #define TI3030_RAMDAC		(VENDOR_TI << 16) | 0x00
@@ -86,6 +101,6 @@ extern _X_EXPORT TIramdacLoadPaletteProc *TIramdacLoadPaletteWeak(void);
 
 #define TIDAC_sw_reset		0xff
 
-/* Constants */  
+/* Constants */
 #define TIDAC_TVP_3026_ID       0x26
 #define TIDAC_TVP_3030_ID       0x30
diff --git a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
index 1e0f7e0b7..678d2be5c 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
@@ -30,46 +30,44 @@ static Bool xf86DeviceCursorInitialize(DeviceIntPtr, ScreenPtr);
 static void xf86DeviceCursorCleanup(DeviceIntPtr, ScreenPtr);
 
 static miPointerSpriteFuncRec xf86CursorSpriteFuncs = {
-   xf86CursorRealizeCursor,
-   xf86CursorUnrealizeCursor,
-   xf86CursorSetCursor,
-   xf86CursorMoveCursor,
-   xf86DeviceCursorInitialize,
-   xf86DeviceCursorCleanup
+    xf86CursorRealizeCursor,
+    xf86CursorUnrealizeCursor,
+    xf86CursorSetCursor,
+    xf86CursorMoveCursor,
+    xf86DeviceCursorInitialize,
+    xf86DeviceCursorCleanup
 };
 
 /* Screen functions */
 
 static void xf86CursorInstallColormap(ColormapPtr);
-static void xf86CursorRecolorCursor(DeviceIntPtr pDev, ScreenPtr, CursorPtr, Bool);
+static void xf86CursorRecolorCursor(DeviceIntPtr pDev, ScreenPtr, CursorPtr,
+                                    Bool);
 static Bool xf86CursorCloseScreen(int, ScreenPtr);
-static void xf86CursorQueryBestSize(int, unsigned short*, unsigned short*,
-				    ScreenPtr);
+static void xf86CursorQueryBestSize(int, unsigned short *, unsigned short *,
+                                    ScreenPtr);
 
 /* ScrnInfoRec functions */
 
 static void xf86CursorEnableDisableFBAccess(int, Bool);
-static Bool xf86CursorSwitchMode(int, DisplayModePtr,int);
+static Bool xf86CursorSwitchMode(int, DisplayModePtr, int);
 
 Bool
-xf86InitCursor(
-   ScreenPtr pScreen,
-   xf86CursorInfoPtr infoPtr
-)
+xf86InitCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr)
 {
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
     xf86CursorScreenPtr ScreenPriv;
     miPointerScreenPtr PointPriv;
 
     if (!xf86InitHardwareCursor(pScreen, infoPtr))
-	return FALSE;
+        return FALSE;
 
     if (!dixRegisterPrivateKey(&xf86CursorScreenKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
     ScreenPriv = calloc(1, sizeof(xf86CursorScreenRec));
     if (!ScreenPriv)
-	return FALSE;
+        return FALSE;
 
     dixSetPrivate(&pScreen->devPrivates, xf86CursorScreenKey, ScreenPriv);
 
@@ -88,31 +86,31 @@ xf86InitCursor(
     pScreen->RecolorCursor = xf86CursorRecolorCursor;
 
     if ((infoPtr->pScrn->bitsPerPixel == 8) &&
-	!(infoPtr->Flags & HARDWARE_CURSOR_TRUECOLOR_AT_8BPP)) {
-	ScreenPriv->InstallColormap = pScreen->InstallColormap;
-	pScreen->InstallColormap = xf86CursorInstallColormap;
-	ScreenPriv->PalettedCursor = TRUE;
+        !(infoPtr->Flags & HARDWARE_CURSOR_TRUECOLOR_AT_8BPP)) {
+        ScreenPriv->InstallColormap = pScreen->InstallColormap;
+        pScreen->InstallColormap = xf86CursorInstallColormap;
+        ScreenPriv->PalettedCursor = TRUE;
     }
 
     PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);
 
     ScreenPriv->showTransparent = PointPriv->showTransparent;
     if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT)
-	PointPriv->showTransparent = TRUE;
+        PointPriv->showTransparent = TRUE;
     else
-	PointPriv->showTransparent = FALSE;
+        PointPriv->showTransparent = FALSE;
     ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
     PointPriv->spriteFuncs = &xf86CursorSpriteFuncs;
 
     ScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
     ScreenPriv->SwitchMode = pScrn->SwitchMode;
-    
+
     ScreenPriv->ForceHWCursorCount = 0;
     ScreenPriv->HWCursorForced = FALSE;
 
     pScrn->EnableDisableFBAccess = xf86CursorEnableDisableFBAccess;
     if (pScrn->SwitchMode)
-	pScrn->SwitchMode = xf86CursorSwitchMode;
+        pScrn->SwitchMode = xf86CursorSwitchMode;
 
     return TRUE;
 }
@@ -123,22 +121,24 @@ static Bool
 xf86CursorCloseScreen(int i, ScreenPtr pScreen)
 {
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    miPointerScreenPtr PointPriv = (miPointerScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, miPointerScreenKey);
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    miPointerScreenPtr PointPriv =
+        (miPointerScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                              miPointerScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (ScreenPriv->isUp && pScrn->vtSema)
-	xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
+        xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
 
     if (ScreenPriv->CurrentCursor)
-	FreeCursor(ScreenPriv->CurrentCursor, None);
+        FreeCursor(ScreenPriv->CurrentCursor, None);
 
     pScreen->CloseScreen = ScreenPriv->CloseScreen;
     pScreen->QueryBestSize = ScreenPriv->QueryBestSize;
     pScreen->RecolorCursor = ScreenPriv->RecolorCursor;
     if (ScreenPriv->InstallColormap)
-	pScreen->InstallColormap = ScreenPriv->InstallColormap;
+        pScreen->InstallColormap = ScreenPriv->InstallColormap;
 
     PointPriv->spriteFuncs = ScreenPriv->spriteFuncs;
     PointPriv->showTransparent = ScreenPriv->showTransparent;
@@ -149,92 +149,90 @@ xf86CursorCloseScreen(int i, ScreenPtr pScreen)
     free(ScreenPriv->transparentData);
     free(ScreenPriv);
 
-    return (*pScreen->CloseScreen)(i, pScreen);
+    return (*pScreen->CloseScreen) (i, pScreen);
 }
 
 static void
-xf86CursorQueryBestSize(
-   int class,
-   unsigned short *width,
-   unsigned short *height,
-   ScreenPtr pScreen)
+xf86CursorQueryBestSize(int class,
+                        unsigned short *width,
+                        unsigned short *height, ScreenPtr pScreen)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (class == CursorShape) {
-	if(*width > ScreenPriv->CursorInfoPtr->MaxWidth)
-	   *width = ScreenPriv->CursorInfoPtr->MaxWidth;
-	if(*height > ScreenPriv->CursorInfoPtr->MaxHeight)
-	   *height = ScreenPriv->CursorInfoPtr->MaxHeight;
-    } else
-	(*ScreenPriv->QueryBestSize)(class, width, height, pScreen);
+        if (*width > ScreenPriv->CursorInfoPtr->MaxWidth)
+            *width = ScreenPriv->CursorInfoPtr->MaxWidth;
+        if (*height > ScreenPriv->CursorInfoPtr->MaxHeight)
+            *height = ScreenPriv->CursorInfoPtr->MaxHeight;
+    }
+    else
+        (*ScreenPriv->QueryBestSize) (class, width, height, pScreen);
 }
 
 static void
 xf86CursorInstallColormap(ColormapPtr pMap)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pMap->pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pMap->pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     ScreenPriv->pInstalledMap = pMap;
 
-    (*ScreenPriv->InstallColormap)(pMap);
+    (*ScreenPriv->InstallColormap) (pMap);
 }
 
 static void
-xf86CursorRecolorCursor(
-    DeviceIntPtr pDev,
-    ScreenPtr pScreen,
-    CursorPtr pCurs,
-    Bool displayed)
+xf86CursorRecolorCursor(DeviceIntPtr pDev,
+                        ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (!displayed)
-	return;
+        return;
 
     if (ScreenPriv->SWCursor)
-	(*ScreenPriv->RecolorCursor)(pDev, pScreen, pCurs, displayed);
+        (*ScreenPriv->RecolorCursor) (pDev, pScreen, pCurs, displayed);
     else
-	xf86RecolorCursor(pScreen, pCurs, displayed);
+        xf86RecolorCursor(pScreen, pCurs, displayed);
 }
 
 /***** ScrnInfoRec functions *********/
 
 static void
-xf86CursorEnableDisableFBAccess(
-    int index,
-    Bool enable)
+xf86CursorEnableDisableFBAccess(int index, Bool enable)
 {
     DeviceIntPtr pDev = inputInfo.pointer;
 
     ScreenPtr pScreen = screenInfo.screens[index];
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (!enable && ScreenPriv->CurrentCursor != NullCursor) {
         CursorPtr currentCursor = ScreenPriv->CurrentCursor;
+
         xf86CursorSetCursor(pDev, pScreen, NullCursor, ScreenPriv->x,
-                ScreenPriv->y); 
+                            ScreenPriv->y);
         ScreenPriv->isUp = FALSE;
-	ScreenPriv->SWCursor = TRUE;
-	ScreenPriv->SavedCursor = currentCursor;
+        ScreenPriv->SWCursor = TRUE;
+        ScreenPriv->SavedCursor = currentCursor;
     }
 
     if (ScreenPriv->EnableDisableFBAccess)
-	(*ScreenPriv->EnableDisableFBAccess)(index, enable);
-
-    if (enable && ScreenPriv->SavedCursor)
-    {
-	/*
-	 * Re-set current cursor so drivers can react to FB access having been
-	 * temporarily disabled.
-	 */
-	xf86CursorSetCursor(pDev, pScreen, ScreenPriv->SavedCursor,
-			    ScreenPriv->x, ScreenPriv->y);
-	ScreenPriv->SavedCursor = NULL;
+        (*ScreenPriv->EnableDisableFBAccess) (index, enable);
+
+    if (enable && ScreenPriv->SavedCursor) {
+        /*
+         * Re-set current cursor so drivers can react to FB access having been
+         * temporarily disabled.
+         */
+        xf86CursorSetCursor(pDev, pScreen, ScreenPriv->SavedCursor,
+                            ScreenPriv->x, ScreenPriv->y);
+        ScreenPriv->SavedCursor = NULL;
     }
 }
 
@@ -243,15 +241,16 @@ xf86CursorSwitchMode(int index, DisplayModePtr mode, int flags)
 {
     Bool ret;
     ScreenPtr pScreen = screenInfo.screens[index];
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (ScreenPriv->isUp) {
-	xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
-	ScreenPriv->isUp = FALSE;
+        xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
+        ScreenPriv->isUp = FALSE;
     }
 
-    ret = (*ScreenPriv->SwitchMode)(index, mode, flags);
+    ret = (*ScreenPriv->SwitchMode) (index, mode, flags);
 
     /*
      * Cannot restore cursor here because the new frame[XY][01] haven't been
@@ -259,7 +258,7 @@ xf86CursorSwitchMode(int index, DisplayModePtr mode, int flags)
      * ensure the cursor is repainted by miPointerWarpCursor().
      */
     ScreenPriv->CursorToRestore = ScreenPriv->CurrentCursor;
-    miPointerSetWaitForUpdate(pScreen, FALSE);	/* Force cursor repaint */
+    miPointerSetWaitForUpdate(pScreen, FALSE);  /* Force cursor repaint */
 
     return ret;
 }
@@ -269,90 +268,107 @@ xf86CursorSwitchMode(int index, DisplayModePtr mode, int flags)
 static Bool
 xf86CursorRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (pCurs->refcnt <= 1)
-	dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen, NULL);
+        dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
+                            NULL);
 
-    return (*ScreenPriv->spriteFuncs->RealizeCursor)(pDev, pScreen, pCurs);
+    return (*ScreenPriv->spriteFuncs->RealizeCursor) (pDev, pScreen, pCurs);
 }
 
 static Bool
-xf86CursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, 
-                          CursorPtr pCurs)
+xf86CursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     if (pCurs->refcnt <= 1) {
-	free(dixLookupScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen));
-	dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen, NULL);
+        free(dixLookupScreenPrivate
+             (&pCurs->devPrivates, CursorScreenKey, pScreen));
+        dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
+                            NULL);
     }
 
-    return (*ScreenPriv->spriteFuncs->UnrealizeCursor)(pDev, pScreen, pCurs);
+    return (*ScreenPriv->spriteFuncs->UnrealizeCursor) (pDev, pScreen, pCurs);
 }
 
 static void
-xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs, 
+xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
                     int x, int y)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
     xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
 
-    if (pCurs == NullCursor) {	/* means we're supposed to remove the cursor */
+    if (pCurs == NullCursor) {  /* means we're supposed to remove the cursor */
         if (ScreenPriv->SWCursor ||
             !(GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer))
-                (*ScreenPriv->spriteFuncs->SetCursor)(pDev, pScreen, NullCursor, x, y);
+            (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, NullCursor, x,
+                                                   y);
         else if (ScreenPriv->isUp) {
             xf86SetCursor(pScreen, NullCursor, x, y);
             ScreenPriv->isUp = FALSE;
         }
-	if (ScreenPriv->CurrentCursor)
-	    FreeCursor(ScreenPriv->CurrentCursor, None);
+        if (ScreenPriv->CurrentCursor)
+            FreeCursor(ScreenPriv->CurrentCursor, None);
         ScreenPriv->CurrentCursor = NullCursor;
         return;
     }
 
     /* only update for VCP, otherwise we get cursor jumps when removing a
        sprite. The second cursor is never HW rendered anyway. */
-    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer)
-    {
-	pCurs->refcnt++;
-	if (ScreenPriv->CurrentCursor)
-	    FreeCursor(ScreenPriv->CurrentCursor, None);
-	ScreenPriv->CurrentCursor = pCurs;
-	ScreenPriv->x = x;
-	ScreenPriv->y = y;
-	ScreenPriv->CursorToRestore = NULL;
-	ScreenPriv->HotX = pCurs->bits->xhot;
-	ScreenPriv->HotY = pCurs->bits->yhot;
+    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
+        pCurs->refcnt++;
+        if (ScreenPriv->CurrentCursor)
+            FreeCursor(ScreenPriv->CurrentCursor, None);
+        ScreenPriv->CurrentCursor = pCurs;
+        ScreenPriv->x = x;
+        ScreenPriv->y = y;
+        ScreenPriv->CursorToRestore = NULL;
+        ScreenPriv->HotX = pCurs->bits->xhot;
+        ScreenPriv->HotY = pCurs->bits->yhot;
 
         if (!infoPtr->pScrn->vtSema)
             ScreenPriv->SavedCursor = pCurs;
 
-	if (infoPtr->pScrn->vtSema && (ScreenPriv->ForceHWCursorCount || ((
+        if (infoPtr->pScrn->vtSema && (ScreenPriv->ForceHWCursorCount || ((
 #ifdef ARGB_CURSOR
-			    pCurs->bits->argb && infoPtr->UseHWCursorARGB &&
-			    (*infoPtr->UseHWCursorARGB) (pScreen, pCurs) ) || (
-			    pCurs->bits->argb == 0 &&
+                                                                              pCurs->
+                                                                              bits->
+                                                                              argb
+                                                                              &&
+                                                                              infoPtr->
+                                                                              UseHWCursorARGB
+                                                                              &&
+                                                                              (*infoPtr->
+                                                                               UseHWCursorARGB)
+                                                                              (pScreen,
+                                                                               pCurs))
+                                                                          ||
+                                                                          (pCurs->
+                                                                           bits->
+                                                                           argb
+                                                                           == 0
+                                                                           &&
 #endif
-			    (pCurs->bits->height <= infoPtr->MaxHeight) &&
-			    (pCurs->bits->width <= infoPtr->MaxWidth) &&
-                            (!infoPtr->UseHWCursor || (*infoPtr->UseHWCursor)(pScreen, pCurs))))))
-	{
+                                                                           (pCurs->bits->height <= infoPtr->MaxHeight) && (pCurs->bits->width <= infoPtr->MaxWidth) && (!infoPtr->UseHWCursor || (*infoPtr->UseHWCursor) (pScreen, pCurs)))))) {
 
-	    if (ScreenPriv->SWCursor)	/* remove the SW cursor */
-		(*ScreenPriv->spriteFuncs->SetCursor)(pDev, pScreen, NullCursor, x, y);
+            if (ScreenPriv->SWCursor)   /* remove the SW cursor */
+                (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen,
+                                                       NullCursor, x, y);
 
-	    xf86SetCursor(pScreen, pCurs, x, y);
-	    ScreenPriv->SWCursor = FALSE;
-	    ScreenPriv->isUp = TRUE;
+            xf86SetCursor(pScreen, pCurs, x, y);
+            ScreenPriv->SWCursor = FALSE;
+            ScreenPriv->isUp = TRUE;
 
-	    miPointerSetWaitForUpdate(pScreen, !infoPtr->pScrn->silkenMouse);
-	    return;
-	}
+            miPointerSetWaitForUpdate(pScreen, !infoPtr->pScrn->silkenMouse);
+            return;
+        }
 
         miPointerSetWaitForUpdate(pScreen, TRUE);
 
@@ -360,7 +376,8 @@ xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
             /* Remove the HW cursor, or make it transparent */
             if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT) {
                 xf86SetTransparentCursor(pScreen);
-            } else {
+            }
+            else {
                 xf86SetCursor(pScreen, NullCursor, x, y);
                 ScreenPriv->isUp = FALSE;
             }
@@ -372,63 +389,61 @@ xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
     }
 
     if (pCurs->bits->emptyMask && !ScreenPriv->showTransparent)
-	pCurs = NullCursor;
+        pCurs = NullCursor;
 
-    (*ScreenPriv->spriteFuncs->SetCursor)(pDev, pScreen, pCurs, x, y);
+    (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, pCurs, x, y);
 }
 
 static void
 xf86CursorMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     /* only update coordinate state for first sprite, otherwise we get jumps
        when removing a sprite. The second sprite is never HW rendered anyway */
-    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer)
-    {
-	ScreenPriv->x = x;
-	ScreenPriv->y = y;
+    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
+        ScreenPriv->x = x;
+        ScreenPriv->y = y;
 
         if (ScreenPriv->CursorToRestore)
-            xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CursorToRestore, x, y);
+            xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CursorToRestore, x,
+                                y);
         else if (ScreenPriv->SWCursor)
-            (*ScreenPriv->spriteFuncs->MoveCursor)(pDev, pScreen, x, y);
+            (*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
         else if (ScreenPriv->isUp)
             xf86MoveCursor(pScreen, x, y);
-    } else
-        (*ScreenPriv->spriteFuncs->MoveCursor)(pDev, pScreen, x, y);
+    }
+    else
+        (*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
 }
 
 void
-xf86ForceHWCursor (ScreenPtr pScreen, Bool on)
+xf86ForceHWCursor(ScreenPtr pScreen, Bool on)
 {
     DeviceIntPtr pDev = inputInfo.pointer;
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
-
-    if (on)
-    {
-	if (ScreenPriv->ForceHWCursorCount++ == 0)
-	{
-	    if (ScreenPriv->SWCursor && ScreenPriv->CurrentCursor)
-	    {
-		ScreenPriv->HWCursorForced = TRUE;
-		xf86CursorSetCursor (pDev, pScreen, ScreenPriv->CurrentCursor,
-				     ScreenPriv->x, ScreenPriv->y);
-	    }
-	    else
-		ScreenPriv->HWCursorForced = FALSE;
-	}
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
+
+    if (on) {
+        if (ScreenPriv->ForceHWCursorCount++ == 0) {
+            if (ScreenPriv->SWCursor && ScreenPriv->CurrentCursor) {
+                ScreenPriv->HWCursorForced = TRUE;
+                xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
+                                    ScreenPriv->x, ScreenPriv->y);
+            }
+            else
+                ScreenPriv->HWCursorForced = FALSE;
+        }
     }
-    else
-    {
-	if (--ScreenPriv->ForceHWCursorCount == 0)
-	{
-	    if (ScreenPriv->HWCursorForced && ScreenPriv->CurrentCursor)
-		xf86CursorSetCursor (pDev, pScreen, ScreenPriv->CurrentCursor,
-				     ScreenPriv->x, ScreenPriv->y);
-	}
+    else {
+        if (--ScreenPriv->ForceHWCursorCount == 0) {
+            if (ScreenPriv->HWCursorForced && ScreenPriv->CurrentCursor)
+                xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
+                                    ScreenPriv->x, ScreenPriv->y);
+        }
     }
 }
 
@@ -451,11 +466,12 @@ static Bool
 xf86DeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
 {
     int ret;
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-            &pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
     /* Init SW cursor */
-    ret = (*ScreenPriv->spriteFuncs->DeviceCursorInitialize)(pDev, pScreen);
+    ret = (*ScreenPriv->spriteFuncs->DeviceCursorInitialize) (pDev, pScreen);
 
     return ret;
 }
@@ -466,10 +482,10 @@ xf86DeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
 static void
 xf86DeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-            &pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
 
-   /* Clean up SW cursor */
-    (*ScreenPriv->spriteFuncs->DeviceCursorCleanup)(pDev, pScreen);
+    /* Clean up SW cursor */
+    (*ScreenPriv->spriteFuncs->DeviceCursorCleanup) (pDev, pScreen);
 }
-
diff --git a/xorg-server/hw/xfree86/ramdac/xf86Cursor.h b/xorg-server/hw/xfree86/ramdac/xf86Cursor.h
index 3f3618b59..5658e7b30 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86Cursor.h
+++ b/xorg-server/hw/xfree86/ramdac/xf86Cursor.h
@@ -10,13 +10,13 @@ typedef struct _xf86CursorInfoRec {
     int Flags;
     int MaxWidth;
     int MaxHeight;
-    void (*SetCursorColors)(ScrnInfoPtr pScrn, int bg, int fg);
-    void (*SetCursorPosition)(ScrnInfoPtr pScrn, int x, int y);
-    void (*LoadCursorImage)(ScrnInfoPtr pScrn, unsigned char *bits);
-    void (*HideCursor)(ScrnInfoPtr pScrn);
-    void (*ShowCursor)(ScrnInfoPtr pScrn);
-    unsigned char* (*RealizeCursor)(struct _xf86CursorInfoRec *, CursorPtr);
-    Bool (*UseHWCursor)(ScreenPtr, CursorPtr);
+    void (*SetCursorColors) (ScrnInfoPtr pScrn, int bg, int fg);
+    void (*SetCursorPosition) (ScrnInfoPtr pScrn, int x, int y);
+    void (*LoadCursorImage) (ScrnInfoPtr pScrn, unsigned char *bits);
+    void (*HideCursor) (ScrnInfoPtr pScrn);
+    void (*ShowCursor) (ScrnInfoPtr pScrn);
+    unsigned char *(*RealizeCursor) (struct _xf86CursorInfoRec *, CursorPtr);
+    Bool (*UseHWCursor) (ScreenPtr, CursorPtr);
 
 #ifdef ARGB_CURSOR
     Bool (*UseHWCursorARGB) (ScreenPtr, CursorPtr);
@@ -25,10 +25,11 @@ typedef struct _xf86CursorInfoRec {
 
 } xf86CursorInfoRec, *xf86CursorInfoPtr;
 
-extern _X_EXPORT Bool xf86InitCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr);
+extern _X_EXPORT Bool xf86InitCursor(ScreenPtr pScreen,
+                                     xf86CursorInfoPtr infoPtr);
 extern _X_EXPORT xf86CursorInfoPtr xf86CreateCursorInfoRec(void);
 extern _X_EXPORT void xf86DestroyCursorInfoRec(xf86CursorInfoPtr);
-extern _X_EXPORT void xf86ForceHWCursor (ScreenPtr pScreen, Bool on);
+extern _X_EXPORT void xf86ForceHWCursor(ScreenPtr pScreen, Bool on);
 
 #define HARDWARE_CURSOR_INVERT_MASK 			0x00000001
 #define HARDWARE_CURSOR_AND_SOURCE_WITH_MASK		0x00000002
@@ -48,4 +49,4 @@ extern _X_EXPORT void xf86ForceHWCursor (ScreenPtr pScreen, Bool on);
 #define HARDWARE_CURSOR_ARGB				0x00004000
 #endif
 
-#endif /* _XF86CURSOR_H */
+#endif                          /* _XF86CURSOR_H */
diff --git a/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c b/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
index f9b09fc9a..95721490a 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
@@ -39,18 +39,18 @@ static CARD64 xf86CARD64ReverseBits(CARD64 w);
 static CARD64
 xf86CARD64ReverseBits(CARD64 w)
 {
-  unsigned char *p = (unsigned char *)&w;
-
-  p[0] = byte_reversed[p[0]];
-  p[1] = byte_reversed[p[1]];
-  p[2] = byte_reversed[p[2]];
-  p[3] = byte_reversed[p[3]];
-  p[4] = byte_reversed[p[4]];
-  p[5] = byte_reversed[p[5]];
-  p[6] = byte_reversed[p[6]];
-  p[7] = byte_reversed[p[7]];
-
-  return w;
+    unsigned char *p = (unsigned char *) &w;
+
+    p[0] = byte_reversed[p[0]];
+    p[1] = byte_reversed[p[1]];
+    p[2] = byte_reversed[p[2]];
+    p[3] = byte_reversed[p[3]];
+    p[4] = byte_reversed[p[4]];
+    p[5] = byte_reversed[p[5]];
+    p[6] = byte_reversed[p[6]];
+    p[7] = byte_reversed[p[7]];
+
+    return w;
 }
 #endif
 
@@ -61,48 +61,48 @@ xf86CARD64ReverseBits(CARD64 w)
 #define CUR_LOG2_BITMAP_PAD LOG2_BITMAP_PAD
 #define REVERSE_BIT_ORDER(w) xf86ReverseBitOrder(w)
 
-#endif /* BITMAP_SCANLINE_PAD == 64 */
+#endif                          /* BITMAP_SCANLINE_PAD == 64 */
 
-static unsigned char* RealizeCursorInterleave0(xf86CursorInfoPtr, CursorPtr);
-static unsigned char* RealizeCursorInterleave1(xf86CursorInfoPtr, CursorPtr);
-static unsigned char* RealizeCursorInterleave8(xf86CursorInfoPtr, CursorPtr);
-static unsigned char* RealizeCursorInterleave16(xf86CursorInfoPtr, CursorPtr);
-static unsigned char* RealizeCursorInterleave32(xf86CursorInfoPtr, CursorPtr);
-static unsigned char* RealizeCursorInterleave64(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave0(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave1(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave8(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave16(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave32(xf86CursorInfoPtr, CursorPtr);
+static unsigned char *RealizeCursorInterleave64(xf86CursorInfoPtr, CursorPtr);
 
 Bool
 xf86InitHardwareCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr)
 {
     if ((infoPtr->MaxWidth <= 0) || (infoPtr->MaxHeight <= 0))
-	return FALSE;
+        return FALSE;
 
     /* These are required for now */
     if (!infoPtr->SetCursorPosition ||
-	!infoPtr->LoadCursorImage ||
-	!infoPtr->HideCursor ||
-	!infoPtr->ShowCursor ||
-	!infoPtr->SetCursorColors)
-	return FALSE;
+        !infoPtr->LoadCursorImage ||
+        !infoPtr->HideCursor ||
+        !infoPtr->ShowCursor || !infoPtr->SetCursorColors)
+        return FALSE;
 
     if (infoPtr->RealizeCursor) {
-	/* Don't overwrite a driver provided Realize Cursor function */
-    } else
-    if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1 & infoPtr->Flags) {
-	infoPtr->RealizeCursor = RealizeCursorInterleave1;
-    } else
-    if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8 & infoPtr->Flags) {
-	infoPtr->RealizeCursor = RealizeCursorInterleave8;
-    } else
-    if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16 & infoPtr->Flags) {
-	infoPtr->RealizeCursor = RealizeCursorInterleave16;
-    } else
-    if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32 & infoPtr->Flags) {
-	infoPtr->RealizeCursor = RealizeCursorInterleave32;
-    } else
-    if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 & infoPtr->Flags) {
-	infoPtr->RealizeCursor = RealizeCursorInterleave64;
-    } else {    /* not interleaved */
-	infoPtr->RealizeCursor = RealizeCursorInterleave0;
+        /* Don't overwrite a driver provided Realize Cursor function */
+    }
+    else if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1 & infoPtr->Flags) {
+        infoPtr->RealizeCursor = RealizeCursorInterleave1;
+    }
+    else if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8 & infoPtr->Flags) {
+        infoPtr->RealizeCursor = RealizeCursorInterleave8;
+    }
+    else if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16 & infoPtr->Flags) {
+        infoPtr->RealizeCursor = RealizeCursorInterleave16;
+    }
+    else if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32 & infoPtr->Flags) {
+        infoPtr->RealizeCursor = RealizeCursorInterleave32;
+    }
+    else if (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 & infoPtr->Flags) {
+        infoPtr->RealizeCursor = RealizeCursorInterleave64;
+    }
+    else {                      /* not interleaved */
+        infoPtr->RealizeCursor = RealizeCursorInterleave0;
     }
 
     infoPtr->pScrn = xf86Screens[pScreen->myNum];
@@ -113,17 +113,19 @@ xf86InitHardwareCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr)
 void
 xf86SetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
     xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
     unsigned char *bits;
 
     if (pCurs == NullCursor) {
-	(*infoPtr->HideCursor)(infoPtr->pScrn);
-	return;
+        (*infoPtr->HideCursor) (infoPtr->pScrn);
+        return;
     }
 
-    bits = dixLookupScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen);
+    bits =
+        dixLookupScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen);
 
     x -= infoPtr->pScrn->frameX0 + ScreenPriv->HotX;
     y -= infoPtr->pScrn->frameY0 + ScreenPriv->HotY;
@@ -131,68 +133,72 @@ xf86SetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y)
 #ifdef ARGB_CURSOR
     if (!pCurs->bits->argb || !infoPtr->LoadCursorARGB)
 #endif
-    if (!bits) {
-	bits = (*infoPtr->RealizeCursor)(infoPtr, pCurs);
-	dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen, bits);
-    }
+        if (!bits) {
+            bits = (*infoPtr->RealizeCursor) (infoPtr, pCurs);
+            dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
+                                bits);
+        }
 
     if (!(infoPtr->Flags & HARDWARE_CURSOR_UPDATE_UNHIDDEN))
-	(*infoPtr->HideCursor)(infoPtr->pScrn);
+        (*infoPtr->HideCursor) (infoPtr->pScrn);
 
 #ifdef ARGB_CURSOR
     if (pCurs->bits->argb && infoPtr->LoadCursorARGB)
-	(*infoPtr->LoadCursorARGB) (infoPtr->pScrn, pCurs);
+        (*infoPtr->LoadCursorARGB) (infoPtr->pScrn, pCurs);
     else
 #endif
     if (bits)
-	(*infoPtr->LoadCursorImage)(infoPtr->pScrn, bits);
+        (*infoPtr->LoadCursorImage) (infoPtr->pScrn, bits);
 
     xf86RecolorCursor(pScreen, pCurs, 1);
 
-    (*infoPtr->SetCursorPosition)(infoPtr->pScrn, x, y);
+    (*infoPtr->SetCursorPosition) (infoPtr->pScrn, x, y);
 
-    (*infoPtr->ShowCursor)(infoPtr->pScrn);
+    (*infoPtr->ShowCursor) (infoPtr->pScrn);
 }
 
 void
 xf86SetTransparentCursor(ScreenPtr pScreen)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
     xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
 
     if (!ScreenPriv->transparentData)
-	ScreenPriv->transparentData =
-	    (*infoPtr->RealizeCursor)(infoPtr, NullCursor);
+        ScreenPriv->transparentData =
+            (*infoPtr->RealizeCursor) (infoPtr, NullCursor);
 
     if (!(infoPtr->Flags & HARDWARE_CURSOR_UPDATE_UNHIDDEN))
-	(*infoPtr->HideCursor)(infoPtr->pScrn);
+        (*infoPtr->HideCursor) (infoPtr->pScrn);
 
     if (ScreenPriv->transparentData)
-	(*infoPtr->LoadCursorImage)(infoPtr->pScrn,
-				    ScreenPriv->transparentData);
+        (*infoPtr->LoadCursorImage) (infoPtr->pScrn,
+                                     ScreenPriv->transparentData);
 
-    (*infoPtr->ShowCursor)(infoPtr->pScrn);
+    (*infoPtr->ShowCursor) (infoPtr->pScrn);
 }
 
 void
 xf86MoveCursor(ScreenPtr pScreen, int x, int y)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
     xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
 
     x -= infoPtr->pScrn->frameX0 + ScreenPriv->HotX;
     y -= infoPtr->pScrn->frameY0 + ScreenPriv->HotY;
 
-    (*infoPtr->SetCursorPosition)(infoPtr->pScrn, x, y);
+    (*infoPtr->SetCursorPosition) (infoPtr->pScrn, x, y);
 }
 
 void
 xf86RecolorCursor(ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
 {
-    xf86CursorScreenPtr ScreenPriv = (xf86CursorScreenPtr)dixLookupPrivate(
-	&pScreen->devPrivates, xf86CursorScreenKey);
+    xf86CursorScreenPtr ScreenPriv =
+        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
+                                               xf86CursorScreenKey);
     xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
 
 #ifdef ARGB_CURSOR
@@ -203,38 +209,39 @@ xf86RecolorCursor(ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
 #endif
 
     if (ScreenPriv->PalettedCursor) {
-	xColorItem sourceColor, maskColor;
-	ColormapPtr pmap = ScreenPriv->pInstalledMap;
-	
-	if (!pmap)
-	    return;
-
-	sourceColor.red = pCurs->foreRed;
-	sourceColor.green = pCurs->foreGreen;
-	sourceColor.blue = pCurs->foreBlue;
-	FakeAllocColor(pmap, &sourceColor);
-	maskColor.red = pCurs->backRed;
-	maskColor.green = pCurs->backGreen;
-	maskColor.blue = pCurs->backBlue;
-	FakeAllocColor(pmap, &maskColor);
-	FakeFreeColor(pmap, sourceColor.pixel);
-	FakeFreeColor(pmap, maskColor.pixel);
-	(*infoPtr->SetCursorColors)(infoPtr->pScrn,
-		maskColor.pixel, sourceColor.pixel);
-    } else {    /* Pass colors in 8-8-8 RGB format */
-	(*infoPtr->SetCursorColors)(infoPtr->pScrn,
-	    (pCurs->backBlue >> 8) |
-	    ((pCurs->backGreen >> 8) << 8) |
-	    ((pCurs->backRed >> 8) << 16),
-	    (pCurs->foreBlue >> 8) |
-	    ((pCurs->foreGreen >> 8) << 8) |
-	    ((pCurs->foreRed >> 8) << 16)
-	);
+        xColorItem sourceColor, maskColor;
+        ColormapPtr pmap = ScreenPriv->pInstalledMap;
+
+        if (!pmap)
+            return;
+
+        sourceColor.red = pCurs->foreRed;
+        sourceColor.green = pCurs->foreGreen;
+        sourceColor.blue = pCurs->foreBlue;
+        FakeAllocColor(pmap, &sourceColor);
+        maskColor.red = pCurs->backRed;
+        maskColor.green = pCurs->backGreen;
+        maskColor.blue = pCurs->backBlue;
+        FakeAllocColor(pmap, &maskColor);
+        FakeFreeColor(pmap, sourceColor.pixel);
+        FakeFreeColor(pmap, maskColor.pixel);
+        (*infoPtr->SetCursorColors) (infoPtr->pScrn,
+                                     maskColor.pixel, sourceColor.pixel);
+    }
+    else {                      /* Pass colors in 8-8-8 RGB format */
+        (*infoPtr->SetCursorColors) (infoPtr->pScrn,
+                                     (pCurs->backBlue >> 8) |
+                                     ((pCurs->backGreen >> 8) << 8) |
+                                     ((pCurs->backRed >> 8) << 16),
+                                     (pCurs->foreBlue >> 8) |
+                                     ((pCurs->foreGreen >> 8) << 8) |
+                                     ((pCurs->foreRed >> 8) << 16)
+            );
     }
 }
 
 /* These functions assume that MaxWidth is a multiple of 32 */
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave0(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
 
@@ -243,75 +250,83 @@ RealizeCursorInterleave0(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     unsigned char *mem;
     int size = (infoPtr->MaxWidth * infoPtr->MaxHeight) >> 2;
     int SrcPitch, DstPitch, Pitch, y, x;
+
     /* how many words are in the source or mask */
     int words = size / (CUR_BITMAP_SCANLINE_PAD / 4);
 
-
     if (!(mem = calloc(1, size)))
-	return NULL;
+        return NULL;
 
     if (pCurs == NullCursor) {
-	if (infoPtr->Flags & HARDWARE_CURSOR_INVERT_MASK) {
-	    DstM = (SCANLINE*)mem;
-	    if (!(infoPtr->Flags & HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK))
-		DstM += words;
-	    memset(DstM, -1, words * sizeof(SCANLINE));
-	}
-	return mem;
+        if (infoPtr->Flags & HARDWARE_CURSOR_INVERT_MASK) {
+            DstM = (SCANLINE *) mem;
+            if (!(infoPtr->Flags & HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK))
+                DstM += words;
+            memset(DstM, -1, words * sizeof(SCANLINE));
+        }
+        return mem;
     }
 
     /* SrcPitch == the number of scanlines wide the cursor image is */
     SrcPitch = (pCurs->bits->width + (BITMAP_SCANLINE_PAD - 1)) >>
-      CUR_LOG2_BITMAP_PAD;
+        CUR_LOG2_BITMAP_PAD;
 
     /* DstPitch is the width of the hw cursor in scanlines */
     DstPitch = infoPtr->MaxWidth >> CUR_LOG2_BITMAP_PAD;
     Pitch = SrcPitch < DstPitch ? SrcPitch : DstPitch;
 
-    SrcS = (SCANLINE*)pCurs->bits->source;
-    SrcM = (SCANLINE*)pCurs->bits->mask;
-    DstS = (SCANLINE*)mem;
+    SrcS = (SCANLINE *) pCurs->bits->source;
+    SrcM = (SCANLINE *) pCurs->bits->mask;
+    DstS = (SCANLINE *) mem;
     DstM = DstS + words;
 
     if (infoPtr->Flags & HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK) {
-	SCANLINE *tmp;
-	tmp = DstS; DstS = DstM; DstM = tmp;
+        SCANLINE *tmp;
+
+        tmp = DstS;
+        DstS = DstM;
+        DstM = tmp;
     }
 
     if (infoPtr->Flags & HARDWARE_CURSOR_AND_SOURCE_WITH_MASK) {
-	for(y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
-	    y--;
-	    pSrc+=DstPitch, pMsk+=DstPitch, SrcS+=SrcPitch, SrcM+=SrcPitch) {
-	    for(x = 0; x < Pitch; x++) {
-		pSrc[x] = SrcS[x] & SrcM[x];
-		pMsk[x] = SrcM[x];
-	    }
-	}
-    } else {
-	for(y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
-	    y--;
-	    pSrc+=DstPitch, pMsk+=DstPitch, SrcS+=SrcPitch, SrcM+=SrcPitch) {
-	    for(x = 0; x < Pitch; x++) {
-		pSrc[x] = SrcS[x];
-		pMsk[x] = SrcM[x];
-	    }
-	}
+        for (y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
+             y--;
+             pSrc += DstPitch, pMsk += DstPitch, SrcS += SrcPitch, SrcM +=
+             SrcPitch) {
+            for (x = 0; x < Pitch; x++) {
+                pSrc[x] = SrcS[x] & SrcM[x];
+                pMsk[x] = SrcM[x];
+            }
+        }
+    }
+    else {
+        for (y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
+             y--;
+             pSrc += DstPitch, pMsk += DstPitch, SrcS += SrcPitch, SrcM +=
+             SrcPitch) {
+            for (x = 0; x < Pitch; x++) {
+                pSrc[x] = SrcS[x];
+                pMsk[x] = SrcM[x];
+            }
+        }
     }
 
     if (infoPtr->Flags & HARDWARE_CURSOR_NIBBLE_SWAPPED) {
-	int count = size;
-	unsigned char* pntr1 = (unsigned char *)DstS;
-	unsigned char* pntr2 = (unsigned char *)DstM;
-	unsigned char a, b;
-	while (count) {
-
-	   a = *pntr1;
-	   b = *pntr2;
-	   *pntr1 = ((a & 0xF0) >> 4) | ((a & 0x0F) << 4);
-	   *pntr2 = ((b & 0xF0) >> 4) | ((b & 0x0F) << 4);
-	   pntr1++; pntr2++;
-	   count-=2;
-	}
+        int count = size;
+        unsigned char *pntr1 = (unsigned char *) DstS;
+        unsigned char *pntr2 = (unsigned char *) DstM;
+        unsigned char a, b;
+
+        while (count) {
+
+            a = *pntr1;
+            b = *pntr2;
+            *pntr1 = ((a & 0xF0) >> 4) | ((a & 0x0F) << 4);
+            *pntr2 = ((b & 0xF0) >> 4) | ((b & 0x0F) << 4);
+            pntr1++;
+            pntr2++;
+            count -= 2;
+        }
     }
 
     /*
@@ -319,29 +334,29 @@ RealizeCursorInterleave0(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
      * out entire source mask.
      */
     if (infoPtr->Flags & HARDWARE_CURSOR_INVERT_MASK) {
-	int count = words;
-	SCANLINE* pntr = DstM;
-	while (count--) {
-	   *pntr = ~(*pntr);
-	    pntr++;
-	}
+        int count = words;
+        SCANLINE *pntr = DstM;
+
+        while (count--) {
+            *pntr = ~(*pntr);
+            pntr++;
+        }
     }
 
     if (infoPtr->Flags & HARDWARE_CURSOR_BIT_ORDER_MSBFIRST) {
-	for(y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
-	    y--;
-	    pSrc+=DstPitch, pMsk+=DstPitch) {
-	    for(x = 0; x < Pitch; x++) {
-		pSrc[x] = REVERSE_BIT_ORDER(pSrc[x]);
-		pMsk[x] = REVERSE_BIT_ORDER(pMsk[x]);
-	    }
-	}
+        for (y = pCurs->bits->height, pSrc = DstS, pMsk = DstM;
+             y--; pSrc += DstPitch, pMsk += DstPitch) {
+            for (x = 0; x < Pitch; x++) {
+                pSrc[x] = REVERSE_BIT_ORDER(pSrc[x]);
+                pMsk[x] = REVERSE_BIT_ORDER(pMsk[x]);
+            }
+        }
     }
 
     return mem;
 }
 
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave1(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
     unsigned char *DstS, *DstM;
@@ -352,30 +367,30 @@ RealizeCursorInterleave1(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 
     /* Realize the cursor without interleaving */
     if (!(mem2 = RealizeCursorInterleave0(infoPtr, pCurs)))
-	return NULL;
+        return NULL;
 
     if (!(mem = calloc(1, size))) {
-	free(mem2);
-	return NULL;
+        free(mem2);
+        return NULL;
     }
 
-     /* 1 bit interleave */
+    /* 1 bit interleave */
     DstS = mem2;
     DstM = DstS + (size >> 1);
     pntr = mem;
     count = size;
     while (count) {
-	*pntr++ = ((*DstS&0x01)     ) | ((*DstM&0x01) << 1) |
-		  ((*DstS&0x02) << 1) | ((*DstM&0x02) << 2) |
-		  ((*DstS&0x04) << 2) | ((*DstM&0x04) << 3) |
-		  ((*DstS&0x08) << 3) | ((*DstM&0x08) << 4);
-	*pntr++ = ((*DstS&0x10) >> 4) | ((*DstM&0x10) >> 3) |
-		  ((*DstS&0x20) >> 3) | ((*DstM&0x20) >> 2) |
-		  ((*DstS&0x40) >> 2) | ((*DstM&0x40) >> 1) |
-		  ((*DstS&0x80) >> 1) | ((*DstM&0x80)     );
-	DstS++;
-	DstM++;
-	count-=2;
+        *pntr++ = ((*DstS & 0x01)) | ((*DstM & 0x01) << 1) |
+            ((*DstS & 0x02) << 1) | ((*DstM & 0x02) << 2) |
+            ((*DstS & 0x04) << 2) | ((*DstM & 0x04) << 3) |
+            ((*DstS & 0x08) << 3) | ((*DstM & 0x08) << 4);
+        *pntr++ = ((*DstS & 0x10) >> 4) | ((*DstM & 0x10) >> 3) |
+            ((*DstS & 0x20) >> 3) | ((*DstM & 0x20) >> 2) |
+            ((*DstS & 0x40) >> 2) | ((*DstM & 0x40) >> 1) |
+            ((*DstS & 0x80) >> 1) | ((*DstM & 0x80));
+        DstS++;
+        DstM++;
+        count -= 2;
     }
 
     /* Free the uninterleaved cursor */
@@ -384,7 +399,7 @@ RealizeCursorInterleave1(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     return mem;
 }
 
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave8(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
     unsigned char *DstS, *DstM;
@@ -395,11 +410,11 @@ RealizeCursorInterleave8(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 
     /* Realize the cursor without interleaving */
     if (!(mem2 = RealizeCursorInterleave0(infoPtr, pCurs)))
-	return NULL;
+        return NULL;
 
     if (!(mem = calloc(1, size))) {
-	free(mem2);
-	return NULL;
+        free(mem2);
+        return NULL;
     }
 
     /* 8 bit interleave */
@@ -408,9 +423,9 @@ RealizeCursorInterleave8(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     pntr = mem;
     count = size;
     while (count) {
-	*pntr++ = *DstS++;
-	*pntr++ = *DstM++;
-	count-=2;
+        *pntr++ = *DstS++;
+        *pntr++ = *DstM++;
+        count -= 2;
     }
 
     /* Free the uninterleaved cursor */
@@ -419,7 +434,7 @@ RealizeCursorInterleave8(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     return mem;
 }
 
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave16(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
     unsigned short *DstS, *DstM;
@@ -430,22 +445,22 @@ RealizeCursorInterleave16(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 
     /* Realize the cursor without interleaving */
     if (!(mem2 = RealizeCursorInterleave0(infoPtr, pCurs)))
-	return NULL;
+        return NULL;
 
     if (!(mem = calloc(1, size))) {
-	free(mem2);
-	return NULL;
+        free(mem2);
+        return NULL;
     }
 
     /* 16 bit interleave */
-    DstS = (pointer)mem2;
+    DstS = (pointer) mem2;
     DstM = DstS + (size >> 2);
-    pntr = (pointer)mem;
+    pntr = (pointer) mem;
     count = (size >> 1);
     while (count) {
-	*pntr++ = *DstS++;
-	*pntr++ = *DstM++;
-	count-=2;
+        *pntr++ = *DstS++;
+        *pntr++ = *DstM++;
+        count -= 2;
     }
 
     /* Free the uninterleaved cursor */
@@ -454,7 +469,7 @@ RealizeCursorInterleave16(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     return mem;
 }
 
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave32(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
     CARD32 *DstS, *DstM;
@@ -465,22 +480,22 @@ RealizeCursorInterleave32(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 
     /* Realize the cursor without interleaving */
     if (!(mem2 = RealizeCursorInterleave0(infoPtr, pCurs)))
-	return NULL;
+        return NULL;
 
     if (!(mem = calloc(1, size))) {
-	free(mem2);
-	return NULL;
+        free(mem2);
+        return NULL;
     }
 
     /* 32 bit interleave */
-    DstS = (pointer)mem2;
+    DstS = (pointer) mem2;
     DstM = DstS + (size >> 3);
-    pntr = (pointer)mem;
+    pntr = (pointer) mem;
     count = (size >> 2);
     while (count) {
-	*pntr++ = *DstS++;
-	*pntr++ = *DstM++;
-	count-=2;
+        *pntr++ = *DstS++;
+        *pntr++ = *DstM++;
+        count -= 2;
     }
 
     /* Free the uninterleaved cursor */
@@ -489,7 +504,7 @@ RealizeCursorInterleave32(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
     return mem;
 }
 
-static unsigned char*
+static unsigned char *
 RealizeCursorInterleave64(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
     CARD32 *DstS, *DstM;
@@ -500,24 +515,24 @@ RealizeCursorInterleave64(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 
     /* Realize the cursor without interleaving */
     if (!(mem2 = RealizeCursorInterleave0(infoPtr, pCurs)))
-	return NULL;
+        return NULL;
 
     if (!(mem = calloc(1, size))) {
-	free(mem2);
-	return NULL;
+        free(mem2);
+        return NULL;
     }
 
     /* 64 bit interleave */
-    DstS = (pointer)mem2;
+    DstS = (pointer) mem2;
     DstM = DstS + (size >> 3);
-    pntr = (pointer)mem;
+    pntr = (pointer) mem;
     count = (size >> 2);
     while (count) {
-	*pntr++ = *DstS++;
-	*pntr++ = *DstS++;
-	*pntr++ = *DstM++;
-	*pntr++ = *DstM++;
-	count-=4;
+        *pntr++ = *DstS++;
+        *pntr++ = *DstS++;
+        *pntr++ = *DstM++;
+        *pntr++ = *DstM++;
+        count -= 4;
     }
 
     /* Free the uninterleaved cursor */
diff --git a/xorg-server/hw/xfree86/ramdac/xf86RamDac.h b/xorg-server/hw/xfree86/ramdac/xf86RamDac.h
index 4a3900b93..50a659a22 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86RamDac.h
+++ b/xorg-server/hw/xfree86/ramdac/xf86RamDac.h
@@ -16,96 +16,63 @@ typedef struct _RamDacRegRec {
  * and they seem o.k 
  * Then we allocate 768 entries for the DAC too. IBM640 needs 1024 -FIXME
  */
-    unsigned short DacRegs[0x400];	/* register set */
-    unsigned char DAC[0x300];		/* colour map */
+    unsigned short DacRegs[0x400];      /* register set */
+    unsigned char DAC[0x300];   /* colour map */
     Bool Overlay;
 } RamDacRegRec, *RamDacRegRecPtr;
 
 typedef struct _RamDacHWRegRec {
-    RamDacRegRec	SavedReg;
-    RamDacRegRec	ModeReg;
+    RamDacRegRec SavedReg;
+    RamDacRegRec ModeReg;
 } RamDacHWRec, *RamDacHWRecPtr;
 
 typedef struct _RamDacRec {
     CARD32 RamDacType;
 
-    void (*LoadPalette)(
-	ScrnInfoPtr pScrn, 
-	int numColors, 
-	int *indices, 
-	LOCO *colors,
-	VisualPtr pVisual
-    );
-
-    unsigned char (*ReadDAC)(
-	ScrnInfoPtr pScrn,
-	CARD32
-    );
-
-    void (*WriteDAC)(
-	ScrnInfoPtr pScrn,
-	CARD32,
-	unsigned char,
-	unsigned char
-    );
-
-    void (*WriteAddress)(
-	ScrnInfoPtr pScrn,
-	CARD32
-    );
-
-    void (*WriteData)(
-	ScrnInfoPtr pScrn,
-	unsigned char
-    );
-
-    void (*ReadAddress)(
-	ScrnInfoPtr pScrn,
-	CARD32
-    );
-
-    unsigned char (*ReadData)(
-	ScrnInfoPtr pScrn
-    );
+    void (*LoadPalette) (ScrnInfoPtr pScrn,
+                         int numColors,
+                         int *indices, LOCO * colors, VisualPtr pVisual);
+
+    unsigned char (*ReadDAC) (ScrnInfoPtr pScrn, CARD32);
+
+    void (*WriteDAC) (ScrnInfoPtr pScrn, CARD32, unsigned char, unsigned char);
+
+    void (*WriteAddress) (ScrnInfoPtr pScrn, CARD32);
+
+    void (*WriteData) (ScrnInfoPtr pScrn, unsigned char);
+
+    void (*ReadAddress) (ScrnInfoPtr pScrn, CARD32);
+
+    unsigned char (*ReadData) (ScrnInfoPtr pScrn);
 } RamDacRec, *RamDacRecPtr;
 
 typedef struct _RamDacHelperRec {
     CARD32 RamDacType;
 
-    void (*Restore)(
-	ScrnInfoPtr pScrn,
-	RamDacRecPtr ramdacPtr,
-	RamDacRegRecPtr ramdacReg
-    );
-
-    void (*Save)(
-	ScrnInfoPtr pScrn,
-	RamDacRecPtr ramdacPtr,
-	RamDacRegRecPtr ramdacReg
-    );
-
-    void (*SetBpp)(
-	ScrnInfoPtr pScrn,
-	RamDacRegRecPtr ramdacReg
-    );
-
-    void (*HWCursorInit)(
-	xf86CursorInfoPtr infoPtr
-    );
+    void (*Restore) (ScrnInfoPtr pScrn,
+                     RamDacRecPtr ramdacPtr, RamDacRegRecPtr ramdacReg);
+
+    void (*Save) (ScrnInfoPtr pScrn,
+                  RamDacRecPtr ramdacPtr, RamDacRegRecPtr ramdacReg);
+
+    void (*SetBpp) (ScrnInfoPtr pScrn, RamDacRegRecPtr ramdacReg);
+
+    void (*HWCursorInit) (xf86CursorInfoPtr infoPtr);
 } RamDacHelperRec, *RamDacHelperRecPtr;
 
 #define RAMDACHWPTR(p) ((RamDacHWRecPtr)((p)->privates[RamDacGetHWIndex()].ptr))
 
 typedef struct _RamdacScreenRec {
-    RamDacRecPtr	RamDacRec;
+    RamDacRecPtr RamDacRec;
 } RamDacScreenRec, *RamDacScreenRecPtr;
+
 #define RAMDACSCRPTR(p) ((RamDacScreenRecPtr)((p)->privates[RamDacGetScreenIndex()].ptr))->RamDacRec
 
 extern _X_EXPORT int RamDacHWPrivateIndex;
 extern _X_EXPORT int RamDacScreenPrivateIndex;
 
 typedef struct {
-    int		token;
+    int token;
 } RamDacSupportedInfoRec, *RamDacSupportedInfoRecPtr;
 
 extern _X_EXPORT RamDacRecPtr RamDacCreateInfoRec(void);
@@ -113,9 +80,9 @@ extern _X_EXPORT RamDacHelperRecPtr RamDacHelperCreateInfoRec(void);
 extern _X_EXPORT void RamDacDestroyInfoRec(RamDacRecPtr RamDacRec);
 extern _X_EXPORT void RamDacHelperDestroyInfoRec(RamDacHelperRecPtr RamDacRec);
 extern _X_EXPORT Bool RamDacInit(ScrnInfoPtr pScrn, RamDacRecPtr RamDacRec);
-extern _X_EXPORT Bool RamDacHandleColormaps(ScreenPtr pScreen, int maxColors, int sigRGBbits,
-			   unsigned int flags);
+extern _X_EXPORT Bool RamDacHandleColormaps(ScreenPtr pScreen, int maxColors,
+                                            int sigRGBbits, unsigned int flags);
 extern _X_EXPORT void RamDacFreeRec(ScrnInfoPtr pScrn);
-extern _X_EXPORT int  RamDacGetHWIndex(void);
+extern _X_EXPORT int RamDacGetHWIndex(void);
 
-#endif /* _XF86RAMDAC_H */
+#endif                          /* _XF86RAMDAC_H */