Whitespace and formatting changes

11 files changed, 5087 insertions, 5859 deletions

diff --git a/src/regsmi.h b/src/regsmi.h
index 6640ec0..c325571 100644
--- a/src/regsmi.h
+++ b/src/regsmi.h
@@ -52,63 +52,51 @@ authorization from the XFree86 Project and SIlicon Motion.
 static __inline__ CARD8
 VGAIN8_INDEX(SMIPtr pSmi, int indexPort, int dataPort, CARD8 index)
 {
-	if (pSmi->IOBase)
-	{
-		MMIO_OUT8(pSmi->IOBase, indexPort, index);
-		return(MMIO_IN8(pSmi->IOBase, dataPort));
-	}
-	else
-	{
-		outb(pSmi->PIOBase + indexPort, index);
-		return(inb(pSmi->PIOBase + dataPort));
-	}
+    if (pSmi->IOBase) {
+	MMIO_OUT8(pSmi->IOBase, indexPort, index);
+	return(MMIO_IN8(pSmi->IOBase, dataPort));
+    } else {
+	outb(pSmi->PIOBase + indexPort, index);
+	return(inb(pSmi->PIOBase + dataPort));
+    }
 }
 
 static __inline__ void
 VGAOUT8_INDEX(SMIPtr pSmi, int indexPort, int dataPort, CARD8 index, CARD8 data)
 {
-	if (pSmi->IOBase)
-	{
-		MMIO_OUT8(pSmi->IOBase, indexPort, index);
-		MMIO_OUT8(pSmi->IOBase, dataPort, data);
-	}
-	else
-	{
-		outb(pSmi->PIOBase + indexPort, index);
-		outb(pSmi->PIOBase + dataPort, data);
-	}
+    if (pSmi->IOBase) {
+	MMIO_OUT8(pSmi->IOBase, indexPort, index);
+	MMIO_OUT8(pSmi->IOBase, dataPort, data);
+    } else {
+	outb(pSmi->PIOBase + indexPort, index);
+	outb(pSmi->PIOBase + dataPort, data);
+    }
 }
 
 static __inline__ CARD8
 VGAIN8(SMIPtr pSmi, int port)
 {
-	if (pSmi->IOBase)
-	{
-		return(MMIO_IN8(pSmi->IOBase, port));
-	}
-	else
-	{
-		return(inb(pSmi->PIOBase + port));
-	}
+    if (pSmi->IOBase) {
+	return(MMIO_IN8(pSmi->IOBase, port));
+    } else {
+	return(inb(pSmi->PIOBase + port));
+    }
 }
 
 static __inline__ void
 VGAOUT8(SMIPtr pSmi, int port, CARD8 data)
 {
-	if (pSmi->IOBase)
-	{
-		MMIO_OUT8(pSmi->IOBase, port, data);
-	}
-	else
-	{
-		outb(pSmi->PIOBase + port, data);
-	}
+    if (pSmi->IOBase) {
+	MMIO_OUT8(pSmi->IOBase, port, data);
+    } else {
+	outb(pSmi->PIOBase + port, data);
+    }
 }
 
 #define OUT_SEQ(pSmi, index, data)	\
-		VGAOUT8_INDEX((pSmi), VGA_SEQ_INDEX, VGA_SEQ_DATA, (index), (data))
+	VGAOUT8_INDEX((pSmi), VGA_SEQ_INDEX, VGA_SEQ_DATA, (index), (data))
 #define IN_SEQ(pSmi, index)			\
-		VGAIN8_INDEX((pSmi), VGA_SEQ_INDEX, VGA_SEQ_DATA, (index))
+	VGAIN8_INDEX((pSmi), VGA_SEQ_INDEX, VGA_SEQ_DATA, (index))
 
 #define WRITE_DPR(pSmi, dpr, data)	MMIO_OUT32(pSmi->DPRBase, dpr, data); DEBUG((VERBLEV, "DPR%02X = %08X\n", dpr, data))
 #define READ_DPR(pSmi, dpr)			MMIO_IN32(pSmi->DPRBase, dpr)
@@ -120,88 +108,82 @@ VGAOUT8(SMIPtr pSmi, int port, CARD8 data)
 #define READ_FPR(pSmi, fpr)                     MMIO_IN32(pSmi->FPRBase, fpr)
 
 /* 2D Engine commands */
-#define SMI_TRANSPARENT_SRC		0x00000100
+#define SMI_TRANSPARENT_SRC	0x00000100
 #define SMI_TRANSPARENT_DEST	0x00000300
 
-#define SMI_OPAQUE_PXL			0x00000000
-#define SMI_TRANSPARENT_PXL		0x00000400
+#define SMI_OPAQUE_PXL		0x00000000
+#define SMI_TRANSPARENT_PXL	0x00000400
 
-#define SMI_MONO_PACK_8			0x00001000
-#define SMI_MONO_PACK_16		0x00002000
-#define SMI_MONO_PACK_32		0x00003000
+#define SMI_MONO_PACK_8		0x00001000
+#define SMI_MONO_PACK_16	0x00002000
+#define SMI_MONO_PACK_32	0x00003000
 
-#define SMI_ROP2_SRC			0x00008000
-#define SMI_ROP2_PAT			0x0000C000
-#define SMI_ROP3				0x00000000
+#define SMI_ROP2_SRC		0x00008000
+#define SMI_ROP2_PAT		0x0000C000
+#define SMI_ROP3		0x00000000
 
-#define SMI_BITBLT				0x00000000
-#define SMI_RECT_FILL			0x00010000
-#define SMI_TRAPEZOID_FILL		0x00030000
+#define SMI_BITBLT		0x00000000
+#define SMI_RECT_FILL		0x00010000
+#define SMI_TRAPEZOID_FILL	0x00030000
 #define SMI_SHORT_STROKE    	0x00060000
-#define SMI_BRESENHAM_LINE		0x00070000
-#define SMI_HOSTBLT_WRITE		0x00080000
-#define SMI_HOSTBLT_READ		0x00090000
-#define SMI_ROTATE_BLT			0x000B0000
+#define SMI_BRESENHAM_LINE	0x00070000
+#define SMI_HOSTBLT_WRITE	0x00080000
+#define SMI_HOSTBLT_READ	0x00090000
+#define SMI_ROTATE_BLT		0x000B0000
 
-#define SMI_SRC_COLOR			0x00000000
-#define SMI_SRC_MONOCHROME		0x00400000
+#define SMI_SRC_COLOR		0x00000000
+#define SMI_SRC_MONOCHROME	0x00400000
 
 #define SMI_GRAPHICS_STRETCH	0x00800000
 
-#define SMI_ROTATE_CW			0x01000000
-#define SMI_ROTATE_CCW			0x02000000
+#define SMI_ROTATE_CW		0x01000000
+#define SMI_ROTATE_CCW		0x02000000
 
-#define SMI_MAJOR_X				0x00000000
-#define SMI_MAJOR_Y				0x04000000
+#define SMI_MAJOR_X		0x00000000
+#define SMI_MAJOR_Y		0x04000000
 
-#define SMI_LEFT_TO_RIGHT		0x00000000
-#define SMI_RIGHT_TO_LEFT		0x08000000
+#define SMI_LEFT_TO_RIGHT	0x00000000
+#define SMI_RIGHT_TO_LEFT	0x08000000
 
-#define SMI_COLOR_PATTERN		0x40000000
-#define SMI_MONO_PATTERN		0x00000000
+#define SMI_COLOR_PATTERN	0x40000000
+#define SMI_MONO_PATTERN	0x00000000
 
-#define SMI_QUICK_START			0x10000000
-#define SMI_START_ENGINE		0x80000000
+#define SMI_QUICK_START		0x10000000
+#define SMI_START_ENGINE	0x80000000
 
 #define MAXLOOP 0x100000	/* timeout value for engine waits */
 
-#define ENGINE_IDLE()														   \
-		((VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x16) & 0x08) == 0)
-#define FIFO_EMPTY()														   \
-		((VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x16) & 0x10) != 0)
+#define ENGINE_IDLE()		\
+	((VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x16) & 0x08) == 0)
+#define FIFO_EMPTY()		\
+	((VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x16) & 0x10) != 0)
 
 /* Wait until "v" queue entries are free */
-#define	WaitQueue(v)														   \
-	do																		   \
-	{																		   \
-		if (pSmi->NoPCIRetry)												   \
-		{																	   \
-			int loop = MAXLOOP; mem_barrier();								   \
-			while (!FIFO_EMPTY())											   \
-				if (loop-- == 0) break;										   \
-			if (loop <= 0) SMI_GEReset(pScrn, 1, __LINE__, __FILE__);		   \
-		}																	   \
-	} while (0)
+#define	WaitQueue(v)	  \
+    do {		   \
+	if (pSmi->NoPCIRetry) {	  \
+	    int loop = MAXLOOP; mem_barrier();	  \
+	    while (!FIFO_EMPTY())	   \
+		if (loop-- == 0) break;	  \
+	    if (loop <= 0) SMI_GEReset(pScrn, 1, __LINE__, __FILE__);  \
+	}		   \
+    } while (0)
 
 /* Wait until GP is idle */
-#define WaitIdle()															   \
-	do																		   \
-	{																		   \
-		int loop = MAXLOOP; mem_barrier();									   \
-		while (!ENGINE_IDLE())												   \
-			if (loop-- == 0) break;											   \
-		if (loop <= 0) SMI_GEReset(pScrn, 1, __LINE__, __FILE__);			   \
-	}																		   \
-	while (0)
+#define WaitIdle()  \
+    do {		  \
+	int loop = MAXLOOP; mem_barrier(); \
+	while (!ENGINE_IDLE())		   \
+	    if (loop-- == 0) break;	   \
+	if (loop <= 0) SMI_GEReset(pScrn, 1, __LINE__, __FILE__);   \
+    } while (0)
 
 /* Wait until GP is idle and queue is empty */
-#define	WaitIdleEmpty()														   \
-	do																		   \
-	{																		   \
-		WaitQueue(MAXFIFO);													   \
-		WaitIdle();															   \
-	}																		   \
-	while (0)
+#define	WaitIdleEmpty()	   \
+    do {		   \
+	WaitQueue(MAXFIFO);	   \
+	WaitIdle();		 \
+    } while (0)
 
 #define RGB8_PSEUDO      (-1)
 #define RGB16_565         0
@@ -210,7 +192,7 @@ VGAOUT8(SMIPtr pSmi, int port, CARD8 data)
 
 /* register defines so we're not hardcoding numbers */
 
-#define FPR00                                           0x0000
+#define FPR00                                   0x0000
 
 /* video window formats - I=indexed, P=packed */
 #define FPR00_FMT_8I                            0x0
diff --git a/src/smi.h b/src/smi.h
index a793931..f20900a 100644
--- a/src/smi.h
+++ b/src/smi.h
@@ -63,7 +63,7 @@ authorization from the XFree86 Project and Silicon Motion.
 /******************************************************************************/
 
 #ifndef SMI_DEBUG
-#	define SMI_DEBUG	0
+#    define SMI_DEBUG	0
 #endif
 
 #define SMI_USE_IMAGE_WRITES	0
@@ -77,179 +77,179 @@ authorization from the XFree86 Project and Silicon Motion.
 /* Driver data structure; this should contain all needed info for a mode */
 typedef struct
 {
-	Bool    modeInit;
-	CARD16	mode;
-	CARD8	SR17, SR18, SR21, SR31, SR32, SR6A, SR6B, SR81, SRA0;
-	CARD8	CR33, CR33_2, CR3A;
-	CARD8	CR40[14], CR40_2[14];
-	CARD8	CR90[16], CR9F_2;
-	CARD8	CRA0[14];
-	CARD8	smiDACMask, smiDacRegs[256][3];
+    Bool    modeInit;
+    CARD16	mode;
+    CARD8	SR17, SR18, SR21, SR31, SR32, SR6A, SR6B, SR81, SRA0;
+    CARD8	CR33, CR33_2, CR3A;
+    CARD8	CR40[14], CR40_2[14];
+    CARD8	CR90[16], CR9F_2;
+    CARD8	CRA0[14];
+    CARD8	smiDACMask, smiDacRegs[256][3];
     /* CZ 2.11.2001: for gamma correction */
     CARD8   CCR66;
     /* end CZ */
-	CARD8	smiFont[8192];
-	CARD32	DPR10, DPR1C, DPR20, DPR24, DPR28, DPR2C, DPR30, DPR3C, DPR40,
-			DPR44;
-	CARD32	VPR00, VPR0C, VPR10;
-	CARD32	CPR00;
-	CARD32	FPR00_, FPR0C_, FPR10_;
-	/* LCD FIFO regs, etc. - dualhead */
-	CARD8   SR22, SR40, SR41, SR42, SR43, SR44, SR45, SR48, SR49,
-		SR4A, SR4B, SR4C;
-	/* PLL controls */
-	CARD8   SR68, SR69, SR6C, SR6D, SR6E, SR6F;
+    CARD8	smiFont[8192];
+    CARD32	DPR10, DPR1C, DPR20, DPR24, DPR28, DPR2C, DPR30, DPR3C, DPR40,
+		DPR44;
+    CARD32	VPR00, VPR0C, VPR10;
+    CARD32	CPR00;
+    CARD32	FPR00_, FPR0C_, FPR10_;
+    /* LCD FIFO regs, etc. - dualhead */
+    CARD8   SR22, SR40, SR41, SR42, SR43, SR44, SR45, SR48, SR49,
+	    SR4A, SR4B, SR4C;
+    /* PLL controls */
+    CARD8   SR68, SR69, SR6C, SR6D, SR6E, SR6F;
 
 } SMIRegRec, *SMIRegPtr;
 
 /* Global PDEV structure. */
 typedef struct
 {
-	/* accel additions */
-	CARD32			AccelCmd;	/* Value for DPR0C */
-	CARD32			Stride;		/* Stride of frame buffer */
-	CARD32			ScissorsLeft;	/* Left/top of current
-						   scissors */
-	CARD32			ScissorsRight;	/* Right/bottom of current
-						   scissors */
-	Bool			ClipTurnedOn;	/* Clipping was turned on by
-						   the previous command */
-	CARD8			SR18Value;	/* PDR#521: original SR18
-						   value */
-	CARD8			SR21Value;	/* PDR#521: original SR21
-						   value */
-	SMIRegRec		SavedReg;	/* console saved mode
-						   registers */
-	SMIRegRec		ModeReg;	/* XServer video state mode
-						   registers */
-	xf86CursorInfoPtr	CursorInfoRec;	/* HW Cursor info */
-
-	Bool			ModeStructInit;	/* Flag indicating ModeReg has
-						   been duped from console
-						   state */
-	int			vgaCRIndex, vgaCRReg;
-	int			width, height;	/* Width and height of the
-						   screen */
-	int			Bpp;		/* Bytes per pixel */
-
-	/* XAA */
-	int			videoRAMBytes;	/* In units as noted, set in
-						   PreInit  */
-	int			videoRAMKBytes;	/* In units as noted, set in
-						   PreInit */
-	unsigned char *		MapBase;	/* Base of mapped memory */
-	int			MapSize;	/* Size of mapped memory */
-	CARD8 *			DPRBase;	/* Base of DPR registers */
-	CARD8 *			VPRBase;	/* Base of VPR registers */
-	CARD8 *			CPRBase;	/* Base of CPR registers */
-    CARD8 *			FPRBase;    /* Base of FPR registers - for 0730 chipset */
-	CARD8 *			DataPortBase;	/* Base of data port */
-	int			DataPortSize;	/* Size of data port */
-	CARD8 *			IOBase;		/* Base of MMIO VGA ports */
-	IOADDRESS		PIOBase;	/* Base of I/O ports */
-	unsigned char *		FBBase;		/* Base of FB */
-	CARD32			FBOffset;	/* Current visual FB starting
-						   location */
-	CARD32			FBCursorOffset;	/* Cursor storage location */
-	CARD32			FBReserved;	/* Reserved memory in frame
-						   buffer */
+    /* accel additions */
+    CARD32		AccelCmd;	/* Value for DPR0C */
+    CARD32		Stride;		/* Stride of frame buffer */
+    CARD32		ScissorsLeft;	/* Left/top of current
+					   scissors */
+    CARD32		ScissorsRight;	/* Right/bottom of current
+					   scissors */
+    Bool		ClipTurnedOn;	/* Clipping was turned on by
+					   the previous command */
+    CARD8		SR18Value;	/* PDR#521: original SR18
+					   value */
+    CARD8		SR21Value;	/* PDR#521: original SR21
+					   value */
+    SMIRegRec		SavedReg;	/* console saved mode
+					   registers */
+    SMIRegRec		ModeReg;	/* XServer video state mode
+					   registers */
+    xf86CursorInfoPtr	CursorInfoRec;	/* HW Cursor info */
+
+    Bool		ModeStructInit;	/* Flag indicating ModeReg has
+					   been duped from console
+					   state */
+    int			vgaCRIndex, vgaCRReg;
+    int			width, height;	/* Width and height of the
+					   screen */
+    int			Bpp;		/* Bytes per pixel */
+
+    /* XAA */
+    int			videoRAMBytes;	/* In units as noted, set in
+					   PreInit  */
+    int			videoRAMKBytes;	/* In units as noted, set in
+					   PreInit */
+    unsigned char *	MapBase;	/* Base of mapped memory */
+    int			MapSize;	/* Size of mapped memory */
+    CARD8 *		DPRBase;	/* Base of DPR registers */
+    CARD8 *		VPRBase;	/* Base of VPR registers */
+    CARD8 *		CPRBase;	/* Base of CPR registers */
+    CARD8 *		FPRBase;    /* Base of FPR registers - for 0730 chipset */
+    CARD8 *		DataPortBase;	/* Base of data port */
+    int			DataPortSize;	/* Size of data port */
+    CARD8 *		IOBase;		/* Base of MMIO VGA ports */
+    IOADDRESS		PIOBase;	/* Base of I/O ports */
+    unsigned char *	FBBase;		/* Base of FB */
+    CARD32		FBOffset;	/* Current visual FB starting
+					   location */
+    CARD32		FBCursorOffset;	/* Cursor storage location */
+    CARD32		FBReserved;	/* Reserved memory in frame
+					   buffer */
 	
-	Bool			PrimaryVidMapped;	/* Flag indicating if
-							   vgaHWMapMem was used
-							   successfully for
-							   this screen */
-	int			MCLK;		/* Memory Clock  */
-	int			GEResetCnt;	/* Limit the number of errors
-						   printed using a counter */
-
-	Bool			pci_burst;	/* Enable PCI burst mode for
-						   reads? */
-	Bool			NoPCIRetry;	/* Disable PCI retries */
-	Bool			fifo_conservative;	/* Adjust fifo for
-							   acceleration? */
-	Bool			fifo_moderate;	/* Adjust fifo for
+    Bool		PrimaryVidMapped;	/* Flag indicating if
+						   vgaHWMapMem was used
+						   successfully for
+						   this screen */
+    int			MCLK;		/* Memory Clock  */
+    int			GEResetCnt;	/* Limit the number of errors
+					   printed using a counter */
+
+    Bool		pci_burst;	/* Enable PCI burst mode for
+					   reads? */
+    Bool		NoPCIRetry;	/* Disable PCI retries */
+    Bool		fifo_conservative;	/* Adjust fifo for
 						   acceleration? */
-	Bool			fifo_aggressive;	/* Adjust fifo for
-							   acceleration? */
-	Bool			NoAccel;	/* Disable Acceleration */
-	Bool			hwcursor;	/* hardware cursor enabled */
-	Bool			ShowCache;	/* Debugging option */
-	Bool			useBIOS;	/* Use BIOS for mode sets */
-	Bool			zoomOnLCD;	/* Zoom on LCD */
+    Bool		fifo_moderate;	/* Adjust fifo for
+					   acceleration? */
+    Bool		fifo_aggressive;	/* Adjust fifo for
+						   acceleration? */
+    Bool		NoAccel;	/* Disable Acceleration */
+    Bool		hwcursor;	/* hardware cursor enabled */
+    Bool		ShowCache;	/* Debugging option */
+    Bool		useBIOS;	/* Use BIOS for mode sets */
+    Bool		zoomOnLCD;	/* Zoom on LCD */
 	
-	CloseScreenProcPtr	CloseScreen;	/* Pointer used to save wrapped
-						   CloseScreen function */
-	XAAInfoRecPtr		AccelInfoRec;	/* XAA info Rec */
-	pciVideoPtr		PciInfo;	/* PCI info vars */
-	PCITAG			PciTag;
-	int			Chipset;	/* Chip info, set using PCI
-						   above */
-	int			ChipRev;
-
-	/* DGA */
-	DGAModePtr		DGAModes;	/* Pointer to DGA modes */
-	int			numDGAModes;	/* Number of DGA modes */
-	Bool			DGAactive;	/* Flag if DGA is active */
-	int			DGAViewportStatus;
-
-	/* DPMS */
-	int			CurrentDPMS;	/* Current DPMS state */
-	unsigned char		DPMS_SR20;	/* Saved DPMS SR20 register */
-	unsigned char		DPMS_SR21;	/* Saved DPMS SR21 register */
-	unsigned char		DPMS_SR31;	/* Saved DPMS SR31 register */
-	unsigned char		DPMS_SR34;	/* Saved DPMS SR34 register */
-
-	/* Panel information */
-	Bool			lcd;		/* LCD active, 1=DSTN, 2=TFT */
-	int			lcdWidth;	/* LCD width */
-	int			lcdHeight;	/* LCD height */
-
-	I2CBusPtr		I2C;		/* Pointer into I2C module */
-	xf86Int10InfoPtr	pInt10;		/* Pointer to INT10 module */
-
-	/* Shadow frame buffer (rotation) */
-	Bool			shadowFB;	/* Flag if shadow buffer is
+    CloseScreenProcPtr	CloseScreen;	/* Pointer used to save wrapped
+					   CloseScreen function */
+    XAAInfoRecPtr	AccelInfoRec;	/* XAA info Rec */
+    pciVideoPtr		PciInfo;	/* PCI info vars */
+    PCITAG		PciTag;
+    int			Chipset;	/* Chip info, set using PCI
+					   above */
+    int			ChipRev;
+
+    /* DGA */
+    DGAModePtr		DGAModes;	/* Pointer to DGA modes */
+    int			numDGAModes;	/* Number of DGA modes */
+    Bool		DGAactive;	/* Flag if DGA is active */
+    int			DGAViewportStatus;
+
+    /* DPMS */
+    int			CurrentDPMS;	/* Current DPMS state */
+    unsigned char	DPMS_SR20;	/* Saved DPMS SR20 register */
+    unsigned char	DPMS_SR21;	/* Saved DPMS SR21 register */
+    unsigned char	DPMS_SR31;	/* Saved DPMS SR31 register */
+    unsigned char	DPMS_SR34;	/* Saved DPMS SR34 register */
+
+    /* Panel information */
+    Bool		lcd;		/* LCD active, 1=DSTN, 2=TFT */
+    int			lcdWidth;	/* LCD width */
+    int			lcdHeight;	/* LCD height */
+
+    I2CBusPtr		I2C;		/* Pointer into I2C module */
+    xf86Int10InfoPtr	pInt10;		/* Pointer to INT10 module */
+
+    /* Shadow frame buffer (rotation) */
+    Bool		shadowFB;	/* Flag if shadow buffer is
 						   used */
-	int			rotate;		/* Rotation flags */
-	int			ShadowPitch;	/* Pitch of shadow buffer */
-	int			ShadowWidthBytes;	/* Width of shadow
-							   buffer in bytes */
-	int			ShadowWidth;	/* Width of shadow buffer in
-						   pixels */
-	int			ShadowHeight;	/* Height of shadow buffer in
-						   pixels */
-	CARD32			saveBufferSize;	/* #670 - FB save buffer size */
-	void *			pSaveBuffer;	/* #670 - FB save buffer */
-    CARD32			fbMapOffset;    /* offset for fb mapping */
-        CARD32			savedFBOffset;	/* #670 - Saved FBOffset value */
-	CARD32			savedFBReserved;	/* #670 - Saved
-							   FBReserved value */
-	CARD8 *			paletteBuffer;	/* #920 - Palette save buffer */
-
-	/* Polylines - #671 */
-	ValidateGCProcPtr	ValidatePolylines;	/* Org.
-							   ValidatePolylines
-							   function */
-	Bool			polyLines;	/* Our polylines patch is
-						   active */
-
-	void (*PointerMoved)(int index, int x, int y);
-
-	int			videoKey;	/* Video chroma key */
-	Bool			ByteSwap;	/* Byte swap for ZV port */
-	Bool			interlaced;	/* True: Interlaced Video */
-	/* XvExtension */
-	XF86VideoAdaptorPtr	ptrAdaptor;	/* Pointer to VideoAdapter
-						   structure */
-	void (*BlockHandler)(int i, pointer blockData, pointer pTimeout,
-						 pointer pReadMask);
-	GCPtr			videoGC;
-	OptionInfoPtr		Options;
-        CARD8 DACmask;
-
-	Bool			Dualhead;
-
-	Bool			IsSwitching; /* when switching modes */
+    int			rotate;		/* Rotation flags */
+    int			ShadowPitch;	/* Pitch of shadow buffer */
+    int			ShadowWidthBytes;	/* Width of shadow
+						   buffer in bytes */
+    int			ShadowWidth;	/* Width of shadow buffer in
+					   pixels */
+    int			ShadowHeight;	/* Height of shadow buffer in
+					   pixels */
+    CARD32		saveBufferSize;	/* #670 - FB save buffer size */
+    void *		pSaveBuffer;	/* #670 - FB save buffer */
+    CARD32		fbMapOffset;    /* offset for fb mapping */
+    CARD32		savedFBOffset;	/* #670 - Saved FBOffset value */
+    CARD32		savedFBReserved;	/* #670 - Saved
+						   FBReserved value */
+    CARD8 *		paletteBuffer;	/* #920 - Palette save buffer */
+
+    /* Polylines - #671 */
+    ValidateGCProcPtr	ValidatePolylines;	/* Org.
+						   ValidatePolylines
+						   function */
+    Bool		polyLines;	/* Our polylines patch is
+					   active */
+
+    void (*PointerMoved)(int index, int x, int y);
+
+    int			videoKey;	/* Video chroma key */
+    Bool		ByteSwap;	/* Byte swap for ZV port */
+    Bool		interlaced;	/* True: Interlaced Video */
+    /* XvExtension */
+    XF86VideoAdaptorPtr	ptrAdaptor;	/* Pointer to VideoAdapter
+					   structure */
+    void (*BlockHandler)(int i, pointer blockData, pointer pTimeout,
+					 pointer pReadMask);
+    GCPtr		videoGC;
+    OptionInfoPtr	Options;
+    CARD8		DACmask;
+
+    Bool		Dualhead;
+
+    Bool		IsSwitching; /* when switching modes */
 
 } SMIRec, *SMIPtr;
 
@@ -260,20 +260,20 @@ typedef struct
 /******************************************************************************/
 
 #if SMI_DEBUG
-#	define VERBLEV 1
-#	define ENTER_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "ENTER\t" PROCNAME \
-									"(%d)\n", __LINE__); xf86Break1()
-#	define DEBUG_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "DEBUG\t" PROCNAME \
-									"(%d)\n", __LINE__); xf86Break2()
-#	define LEAVE_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "LEAVE\t" PROCNAME \
-									"(%d)\n", __LINE__); xf86Break1()
-#	define DEBUG(arg)				xf86ErrorFVerb arg
+#    define VERBLEV 1
+#    define ENTER_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "ENTER\t" PROCNAME \
+								"(%d)\n", __LINE__); xf86Break1()
+#    define DEBUG_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "DEBUG\t" PROCNAME \
+								"(%d)\n", __LINE__); xf86Break2()
+#    define LEAVE_PROC(PROCNAME)	xf86ErrorFVerb(VERBLEV, "LEAVE\t" PROCNAME \
+								"(%d)\n", __LINE__); xf86Break1()
+#    define DEBUG(arg)			xf86ErrorFVerb arg
 #else
-#	define VERBLEV	4
-#	define ENTER_PROC(PROCNAME)
-#	define DEBUG_PROC(PROCNAME)
-#	define LEAVE_PROC(PROCNAME)
-#	define DEBUG(arg)
+#    define VERBLEV	4
+#    define ENTER_PROC(PROCNAME)
+#    define DEBUG_PROC(PROCNAME)
+#    define LEAVE_PROC(PROCNAME)
+#    define DEBUG(arg)
 #endif
 
 /* Some Silicon Motion structs & registers */
diff --git a/src/smi_accel.c b/src/smi_accel.c
index c5b61fc..48075f4 100644
--- a/src/smi_accel.c
+++ b/src/smi_accel.c
@@ -41,27 +41,27 @@ authorization from the XFree86 Project and silicon Motion.
 
 
 static void SMI_SetupForScreenToScreenCopy(ScrnInfoPtr, int, int, int,
-										   unsigned int, int);
+					   unsigned int, int);
 static void SMI_SubsequentScreenToScreenCopy(ScrnInfoPtr, int, int, int, int,
-											 int, int);
+					     int, int);
 static void SMI_SetupForSolidFill(ScrnInfoPtr, int, int, unsigned);
 static void SMI_SubsequentSolidFillRect(ScrnInfoPtr, int, int, int, int);
 static void SMI_SubsequentSolidHorVertLine(ScrnInfoPtr, int, int, int, int);
 static void SMI_SetupForCPUToScreenColorExpandFill(ScrnInfoPtr, int, int, int,
-												   unsigned int);
+						   unsigned int);
 static void SMI_SubsequentCPUToScreenColorExpandFill(ScrnInfoPtr, int, int, int,
-												     int, int);
+						     int, int);
 static void SMI_SetupForMono8x8PatternFill(ScrnInfoPtr, int, int, int, int, int,
-										   unsigned int);
+					   unsigned int);
 static void SMI_SubsequentMono8x8PatternFillRect(ScrnInfoPtr, int, int, int,
-												 int, int, int);
+						 int, int, int);
 static void SMI_SetupForColor8x8PatternFill(ScrnInfoPtr, int, int, int,
-											unsigned int, int);
+					    unsigned int, int);
 static void SMI_SubsequentColor8x8PatternFillRect(ScrnInfoPtr, int, int, int,
-												  int, int, int);
+						  int, int, int);
 #if SMI_USE_IMAGE_WRITES
 static void SMI_SetupForImageWrite(ScrnInfoPtr, int, unsigned int, int, int,
-								   int);
+				   int);
 static void SMI_SubsequentImageWriteRect(ScrnInfoPtr, int, int, int, int, int);
 #endif
 static void SMI_SetClippingRectangle(ScrnInfoPtr, int, int, int, int);
@@ -73,818 +73,738 @@ static void SMI_Polylines(DrawablePtr, GCPtr, int, int, DDXPointPtr);
 Bool
 SMI_AccelInit(ScreenPtr pScreen)
 {
-	XAAInfoRecPtr infoPtr;
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
+    XAAInfoRecPtr infoPtr;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
     /*BoxRec AvailFBArea;*/
-	Bool ret;
+    Bool ret;
     /*int numLines, maxLines;*/
 
-	ENTER_PROC("SMI_AccelInit");
+    ENTER_PROC("SMI_AccelInit");
 
-	pSmi->AccelInfoRec = infoPtr = XAACreateInfoRec();
-	if (infoPtr == NULL)
-	{
-		LEAVE_PROC("SMI_AccelInit");
-		return FALSE;
-	}
-
-	infoPtr->Flags = PIXMAP_CACHE
-				   | LINEAR_FRAMEBUFFER
-				   | OFFSCREEN_PIXMAPS;
-
-	infoPtr->Sync = SMI_AccelSync;
-
-	/* Screen to screen copies */
-	infoPtr->ScreenToScreenCopyFlags = NO_PLANEMASK
-									 | ONLY_TWO_BITBLT_DIRECTIONS;
-	infoPtr->SetupForScreenToScreenCopy = SMI_SetupForScreenToScreenCopy;
-	infoPtr->SubsequentScreenToScreenCopy = SMI_SubsequentScreenToScreenCopy;
-	if (pScrn->bitsPerPixel == 24)
-	{
-		infoPtr->ScreenToScreenCopyFlags |= NO_TRANSPARENCY;
-	}
-	if ((pSmi->Chipset == SMI_LYNX3D) && (pScrn->bitsPerPixel == 8))
-	{
-		infoPtr->ScreenToScreenCopyFlags |= GXCOPY_ONLY;
-	}
-
-	/* Solid Fills */
-	infoPtr->SolidFillFlags = NO_PLANEMASK;
-	infoPtr->SetupForSolidFill = SMI_SetupForSolidFill;
-	infoPtr->SubsequentSolidFillRect = SMI_SubsequentSolidFillRect;
-
-	/* Solid Lines */
-	infoPtr->SolidLineFlags = NO_PLANEMASK;
-	infoPtr->SetupForSolidLine = SMI_SetupForSolidFill;
-	infoPtr->SubsequentSolidHorVertLine = SMI_SubsequentSolidHorVertLine;
-
-	/* Color Expansion Fills */
-	infoPtr->CPUToScreenColorExpandFillFlags = ROP_NEEDS_SOURCE
-											 | NO_PLANEMASK
-											 | BIT_ORDER_IN_BYTE_MSBFIRST
-											 | LEFT_EDGE_CLIPPING
-											 | CPU_TRANSFER_PAD_DWORD
-											 | SCANLINE_PAD_DWORD;
-	infoPtr->ColorExpandBase = pSmi->DataPortBase;
-	infoPtr->ColorExpandRange = pSmi->DataPortSize;
-	infoPtr->SetupForCPUToScreenColorExpandFill =
-			SMI_SetupForCPUToScreenColorExpandFill;
-	infoPtr->SubsequentCPUToScreenColorExpandFill =
-			SMI_SubsequentCPUToScreenColorExpandFill;
-
-	/* 8x8 Mono Pattern Fills */
-	infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK
-									 | HARDWARE_PATTERN_PROGRAMMED_BITS
-									 | HARDWARE_PATTERN_SCREEN_ORIGIN
-									 | BIT_ORDER_IN_BYTE_MSBFIRST;
-	infoPtr->SetupForMono8x8PatternFill = SMI_SetupForMono8x8PatternFill;
-	infoPtr->SubsequentMono8x8PatternFillRect =
-			SMI_SubsequentMono8x8PatternFillRect;
-
-	/* 8x8 Color Pattern Fills */
-	if (!SMI_LYNX3D_SERIES(pSmi->Chipset) || (pScrn->bitsPerPixel != 24))
-	{
-		infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK
-										  | HARDWARE_PATTERN_SCREEN_ORIGIN;
-		infoPtr->SetupForColor8x8PatternFill =
-				SMI_SetupForColor8x8PatternFill;
-		infoPtr->SubsequentColor8x8PatternFillRect =
-				SMI_SubsequentColor8x8PatternFillRect;
-	}
+    pSmi->AccelInfoRec = infoPtr = XAACreateInfoRec();
+    if (infoPtr == NULL) {
+	LEAVE_PROC("SMI_AccelInit");
+	return FALSE;
+    }
+
+    infoPtr->Flags = PIXMAP_CACHE
+		   | LINEAR_FRAMEBUFFER
+		   | OFFSCREEN_PIXMAPS;
+
+    infoPtr->Sync = SMI_AccelSync;
+
+    /* Screen to screen copies */
+    infoPtr->ScreenToScreenCopyFlags = NO_PLANEMASK
+				     | ONLY_TWO_BITBLT_DIRECTIONS;
+    infoPtr->SetupForScreenToScreenCopy = SMI_SetupForScreenToScreenCopy;
+    infoPtr->SubsequentScreenToScreenCopy = SMI_SubsequentScreenToScreenCopy;
+    if (pScrn->bitsPerPixel == 24) {
+	infoPtr->ScreenToScreenCopyFlags |= NO_TRANSPARENCY;
+    }
+    if ((pSmi->Chipset == SMI_LYNX3D) && (pScrn->bitsPerPixel == 8)) {
+	infoPtr->ScreenToScreenCopyFlags |= GXCOPY_ONLY;
+    }
+
+    /* Solid Fills */
+    infoPtr->SolidFillFlags = NO_PLANEMASK;
+    infoPtr->SetupForSolidFill = SMI_SetupForSolidFill;
+    infoPtr->SubsequentSolidFillRect = SMI_SubsequentSolidFillRect;
+
+    /* Solid Lines */
+    infoPtr->SolidLineFlags = NO_PLANEMASK;
+    infoPtr->SetupForSolidLine = SMI_SetupForSolidFill;
+    infoPtr->SubsequentSolidHorVertLine = SMI_SubsequentSolidHorVertLine;
+
+    /* Color Expansion Fills */
+    infoPtr->CPUToScreenColorExpandFillFlags = ROP_NEEDS_SOURCE
+					     | NO_PLANEMASK
+					     | BIT_ORDER_IN_BYTE_MSBFIRST
+					     | LEFT_EDGE_CLIPPING
+					     | CPU_TRANSFER_PAD_DWORD
+					     | SCANLINE_PAD_DWORD;
+    infoPtr->ColorExpandBase = pSmi->DataPortBase;
+    infoPtr->ColorExpandRange = pSmi->DataPortSize;
+    infoPtr->SetupForCPUToScreenColorExpandFill =
+	    SMI_SetupForCPUToScreenColorExpandFill;
+    infoPtr->SubsequentCPUToScreenColorExpandFill =
+	    SMI_SubsequentCPUToScreenColorExpandFill;
+
+    /* 8x8 Mono Pattern Fills */
+    infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK
+				     | HARDWARE_PATTERN_PROGRAMMED_BITS
+				     | HARDWARE_PATTERN_SCREEN_ORIGIN
+				     | BIT_ORDER_IN_BYTE_MSBFIRST;
+    infoPtr->SetupForMono8x8PatternFill = SMI_SetupForMono8x8PatternFill;
+    infoPtr->SubsequentMono8x8PatternFillRect =
+	SMI_SubsequentMono8x8PatternFillRect;
+
+    /* 8x8 Color Pattern Fills */
+    if (!SMI_LYNX3D_SERIES(pSmi->Chipset) || (pScrn->bitsPerPixel != 24)) {
+	infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK
+					  | HARDWARE_PATTERN_SCREEN_ORIGIN;
+	infoPtr->SetupForColor8x8PatternFill =
+		SMI_SetupForColor8x8PatternFill;
+	infoPtr->SubsequentColor8x8PatternFillRect =
+		SMI_SubsequentColor8x8PatternFillRect;
+    }
 
 #if SMI_USE_IMAGE_WRITES
-	/* Image Writes */
-	infoPtr->ImageWriteFlags = ROP_NEEDS_SOURCE
-							 | NO_PLANEMASK
-							 | CPU_TRANSFER_PAD_DWORD
-							 | SCANLINE_PAD_DWORD;
-	infoPtr->ImageWriteBase = pSmi->DataPortBase;
-	infoPtr->ImageWriteRange = pSmi->DataPortSize;
-	infoPtr->SetupForImageWrite = SMI_SetupForImageWrite;
-	infoPtr->SubsequentImageWriteRect = SMI_SubsequentImageWriteRect;
+    /* Image Writes */
+    infoPtr->ImageWriteFlags = ROP_NEEDS_SOURCE
+			     | NO_PLANEMASK
+			     | CPU_TRANSFER_PAD_DWORD
+			     | SCANLINE_PAD_DWORD;
+    infoPtr->ImageWriteBase = pSmi->DataPortBase;
+    infoPtr->ImageWriteRange = pSmi->DataPortSize;
+    infoPtr->SetupForImageWrite = SMI_SetupForImageWrite;
+    infoPtr->SubsequentImageWriteRect = SMI_SubsequentImageWriteRect;
 #endif
 
-	/* Clipping */
-	infoPtr->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
-						   | HARDWARE_CLIP_MONO_8x8_FILL
-						   | HARDWARE_CLIP_COLOR_8x8_FILL
-						   | HARDWARE_CLIP_SOLID_FILL
-						   | HARDWARE_CLIP_SOLID_LINE
-						   | HARDWARE_CLIP_DASHED_LINE;
-	infoPtr->SetClippingRectangle = SMI_SetClippingRectangle;
-	infoPtr->DisableClipping = SMI_DisableClipping;
-
-	/* Pixmap Cache */
-	if (pScrn->bitsPerPixel == 24)
-	{
-		infoPtr->CachePixelGranularity = 16;
-	}
-	else
-	{
-		infoPtr->CachePixelGranularity = 128 / pScrn->bitsPerPixel;
-	}
+    /* Clipping */
+    infoPtr->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
+			   | HARDWARE_CLIP_MONO_8x8_FILL
+			   | HARDWARE_CLIP_COLOR_8x8_FILL
+			   | HARDWARE_CLIP_SOLID_FILL
+			   | HARDWARE_CLIP_SOLID_LINE
+			   | HARDWARE_CLIP_DASHED_LINE;
+    infoPtr->SetClippingRectangle = SMI_SetClippingRectangle;
+    infoPtr->DisableClipping = SMI_DisableClipping;
 
-	/* Offscreen Pixmaps */
-	infoPtr->maxOffPixWidth  = 4096;
-	infoPtr->maxOffPixHeight = 4096;
-	if (pScrn->bitsPerPixel == 24)
-	{
-		infoPtr->maxOffPixWidth = 4096 / 3;
-
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			infoPtr->maxOffPixHeight = 4096 / 3;
-		}
+    /* Pixmap Cache */
+    if (pScrn->bitsPerPixel == 24) {
+	infoPtr->CachePixelGranularity = 16;
+    } else {
+	infoPtr->CachePixelGranularity = 128 / pScrn->bitsPerPixel;
+    }
+
+    /* Offscreen Pixmaps */
+    infoPtr->maxOffPixWidth  = 4096;
+    infoPtr->maxOffPixHeight = 4096;
+    if (pScrn->bitsPerPixel == 24) {
+	infoPtr->maxOffPixWidth = 4096 / 3;
+
+	if (pSmi->Chipset == SMI_LYNX) {
+	    infoPtr->maxOffPixHeight = 4096 / 3;
 	}
+    }
 
-	SMI_EngineReset(pScrn);
+    SMI_EngineReset(pScrn);
 
 
     /* CZ 18.06.2001: moved to smi_driver.c before the NoAccel question
        to have offscreen framebuffer in NoAccel mode */
 #if 0
-	maxLines = pSmi->FBReserved / (pSmi->width * pSmi->Bpp);
-	if (pSmi->rotate)
-	{
-		numLines = maxLines;
-	}
-	else
-	{
+    maxLines = pSmi->FBReserved / (pSmi->width * pSmi->Bpp);
+    if (pSmi->rotate) {
+	numLines = maxLines;
+    } else {
 #if SMI_USE_VIDEO
-		numLines = ((pSmi->FBReserved - pSmi->width * pSmi->Bpp * pSmi->height)
-				 * 25 / 100 + pSmi->width * pSmi->Bpp - 1)
-				 / (pSmi->width * pSmi->Bpp);
-		numLines += pSmi->height;
+	numLines = ((pSmi->FBReserved - pSmi->width * pSmi->Bpp * pSmi->height)
+		   * 25 / 100 + pSmi->width * pSmi->Bpp - 1)
+		   / (pSmi->width * pSmi->Bpp);
+	numLines += pSmi->height;
 #else
-		numLines = maxLines;
+	numLines = maxLines;
 #endif
-	}
-
-	AvailFBArea.x1 = 0;
-	AvailFBArea.y1 = 0;
-	AvailFBArea.x2 = pSmi->width;
-	AvailFBArea.y2 = numLines;
-	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "FrameBuffer Box: %d,%d - %d,%d\n",
-			AvailFBArea.x1, AvailFBArea.y1, AvailFBArea.x2, AvailFBArea.y2);
-	xf86InitFBManager(pScreen, &AvailFBArea);
+    }
+
+    AvailFBArea.x1 = 0;
+    AvailFBArea.y1 = 0;
+    AvailFBArea.x2 = pSmi->width;
+    AvailFBArea.y2 = numLines;
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "FrameBuffer Box: %d,%d - %d,%d\n",
+		AvailFBArea.x1, AvailFBArea.y1, AvailFBArea.x2, AvailFBArea.y2);
+    xf86InitFBManager(pScreen, &AvailFBArea);
 #endif
 
-	ret = XAAInit(pScreen, infoPtr);
-	if (ret && pSmi->shadowFB)										/* #671 */
-	{
-		pSmi->ValidatePolylines = infoPtr->ValidatePolylines;
-		infoPtr->ValidatePolylines = SMI_ValidatePolylines;
-	}
+    ret = XAAInit(pScreen, infoPtr);
+    if (ret && pSmi->shadowFB)	/* #671 */ {
+	pSmi->ValidatePolylines = infoPtr->ValidatePolylines;
+	infoPtr->ValidatePolylines = SMI_ValidatePolylines;
+    }
 
-	LEAVE_PROC("SMI_AccelInit");
-	return(ret);
+    LEAVE_PROC("SMI_AccelInit");
+    return ret;
 }
 
 void
 SMI_GEReset(ScrnInfoPtr pScrn, int from_timeout, int line, char *file)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD8 tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD8 tmp;
 
-	ENTER_PROC("SMI_GEReset");
+    ENTER_PROC("SMI_GEReset");
 
-	if (from_timeout)
-	{
-		if (pSmi->GEResetCnt++ < 10 || xf86GetVerbosity() > 1)
-		{
-			xf86DrvMsg(pScrn->scrnIndex,X_INFO,"\tSMI_GEReset called from %s line %d\n", file, line);
-		}
-	}
-	else
-	{
-		WaitIdleEmpty();
+    if (from_timeout) {
+	if (pSmi->GEResetCnt++ < 10 || xf86GetVerbosity() > 1) {
+	    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"\tSMI_GEReset called from %s line %d\n", file, line);
 	}
+    } else {
+	WaitIdleEmpty();
+    }
 
-	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp | 0x30);
+    tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp | 0x30);
 
-	WaitIdleEmpty();
+    WaitIdleEmpty();
 
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp);
-	SMI_EngineReset(pScrn);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp);
+    SMI_EngineReset(pScrn);
 
-	LEAVE_PROC("SMI_GEReset");
+    LEAVE_PROC("SMI_GEReset");
 }
 
 /* The sync function for the GE */
 void
 SMI_AccelSync(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_AccelSync");
+    ENTER_PROC("SMI_AccelSync");
 
-	WaitIdleEmpty(); /* #161 */
+    WaitIdleEmpty(); /* #161 */
 
-	LEAVE_PROC("SMI_AccelSync");
+    LEAVE_PROC("SMI_AccelSync");
 }
 
 void
 SMI_EngineReset(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD32 DEDataFormat = 0;
-	int i;
-	int xyAddress[] = { 320, 400, 512, 640, 800, 1024, 1280, 1600, 2048 };
-
-	ENTER_PROC("SMI_EngineReset");
-
-	pSmi->Stride = (pSmi->width * pSmi->Bpp + 15) & ~15;
-
-	switch (pScrn->bitsPerPixel)
-	{
-		case 8:
-			DEDataFormat = 0x00000000;
-			break;
-
-		case 16:
-			pSmi->Stride >>= 1;
-			DEDataFormat = 0x00100000;
-			break;
-
-		case 24:
-			DEDataFormat = 0x00300000;
-			break;
-
-		case 32:
-			pSmi->Stride >>= 2;
-			DEDataFormat = 0x00200000;
-			break;
-	}
-	for (i = 0; i < sizeof(xyAddress) / sizeof(xyAddress[0]); i++)
-	{
-		if (pSmi->rotate)
-		{
-			if (xyAddress[i] == pSmi->height)
-			{
-				DEDataFormat |= i << 16;
-				break;
-			}
-		}
-		else
-		{
-			if (xyAddress[i] == pSmi->width)
-			{
-				DEDataFormat |= i << 16;
-				break;
-			}
-		}
-	}
-
-	WaitIdleEmpty();
-	WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
-	WRITE_DPR(pSmi, 0x1C, DEDataFormat);
-	WRITE_DPR(pSmi, 0x24, 0xFFFFFFFF);
-	WRITE_DPR(pSmi, 0x28, 0xFFFFFFFF);
-	WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
-	WRITE_DPR(pSmi, 0x40, pSmi->FBOffset);
-	WRITE_DPR(pSmi, 0x44, pSmi->FBOffset);
-
-	SMI_DisableClipping(pScrn);
-
-	LEAVE_PROC("SMI_EngineReset");
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD32 DEDataFormat = 0;
+    int i;
+    int xyAddress[] = { 320, 400, 512, 640, 800, 1024, 1280, 1600, 2048 };
+
+    ENTER_PROC("SMI_EngineReset");
+
+    pSmi->Stride = (pSmi->width * pSmi->Bpp + 15) & ~15;
+
+    switch (pScrn->bitsPerPixel) {
+    case 8:
+	DEDataFormat = 0x00000000;
+	break;
+    case 16:
+	pSmi->Stride >>= 1;
+	DEDataFormat = 0x00100000;
+	break;
+    case 24:
+	DEDataFormat = 0x00300000;
+	break;
+    case 32:
+	pSmi->Stride >>= 2;
+	DEDataFormat = 0x00200000;
+	break;
+    }
+
+    for (i = 0; i < sizeof(xyAddress) / sizeof(xyAddress[0]); i++) {
+	if (pSmi->rotate) {
+	    if (xyAddress[i] == pSmi->height) {
+		DEDataFormat |= i << 16;
+		break;
+	    }
+	} else {
+	    if (xyAddress[i] == pSmi->width) {
+		DEDataFormat |= i << 16;
+		break;
+	    }
+	}
+    }
+
+    WaitIdleEmpty();
+    WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
+    WRITE_DPR(pSmi, 0x1C, DEDataFormat);
+    WRITE_DPR(pSmi, 0x24, 0xFFFFFFFF);
+    WRITE_DPR(pSmi, 0x28, 0xFFFFFFFF);
+    WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
+    WRITE_DPR(pSmi, 0x40, pSmi->FBOffset >> 3);
+    WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
+
+    SMI_DisableClipping(pScrn);
+
+    LEAVE_PROC("SMI_EngineReset");
 }
 
 /******************************************************************************/
-/*							 Screen to Screen Copies						  */
+/*	Screen to Screen Copies						      */
 /******************************************************************************/
 
 static void
 SMI_SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir, int rop,
-							   unsigned int planemask, int trans)
+			       unsigned int planemask, int trans)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetupForScreenToScreenCopy");
-	DEBUG((VERBLEV, "xdir=%d ydir=%d rop=%02X trans=%08X\n", xdir, ydir,
-			rop, trans));
+    ENTER_PROC("SMI_SetupForScreenToScreenCopy");
+    DEBUG((VERBLEV, "xdir=%d ydir=%d rop=%02X trans=%08X\n", xdir, ydir,
+	   rop, trans));
 
-	pSmi->AccelCmd = XAAGetCopyROP(rop)
-				      | SMI_BITBLT
-				      | SMI_START_ENGINE;
+    pSmi->AccelCmd = XAAGetCopyROP(rop)
+		   | SMI_BITBLT
+		   | SMI_START_ENGINE;
 
-	if ((xdir == -1) || (ydir == -1))
-	{
-		pSmi->AccelCmd |= SMI_RIGHT_TO_LEFT;
-	}
+    if ((xdir == -1) || (ydir == -1)) {
+	pSmi->AccelCmd |= SMI_RIGHT_TO_LEFT;
+    }
 
-	if (trans != -1)
-	{
-		pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x20, trans);
-	}
+    if (trans != -1) {
+	pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x20, trans);
+    }
 
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
-	}
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    }
 
-	LEAVE_PROC("SMI_SetupForScreenToScreenCopy");
+    LEAVE_PROC("SMI_SetupForScreenToScreenCopy");
 }
 
 static void
 SMI_SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
-								 int y2, int w, int h)
+				 int y2, int w, int h)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_SubsequentScreenToScreenCopy");
-	DEBUG((VERBLEV, "x1=%d y1=%d x2=%d y2=%d w=%d h=%d\n", x1, y1, x2, y2, w,
-			h));
-
-	if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT)
-	{
-		x1 += w - 1;
-		y1 += h - 1;
-		x2 += w - 1;
-		y2 += h - 1;
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_SubsequentScreenToScreenCopy");
+    DEBUG((VERBLEV, "x1=%d y1=%d x2=%d y2=%d w=%d h=%d\n", x1, y1, x2, y2, w, h));
+
+    if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT) {
+	x1 += w - 1;
+	y1 += h - 1;
+	x2 += w - 1;
+	y2 += h - 1;
+    }
+
+    if (pScrn->bitsPerPixel == 24) {
+	x1 *= 3;
+	x2 *= 3;
+	w  *= 3;
+
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y1 *= 3;
+	    y2 *= 3;
 	}
 
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x1 *= 3;
-		x2 *= 3;
-		w  *= 3;
-
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y1 *= 3;
-			y2 *= 3;
-		}
-
-		if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT)
-		{
-			x1 += 2;
-			x2 += 2;
-		}
+	if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT) {
+	    x1 += 2;
+	    x2 += 2;
 	}
+    }
 
-	WaitQueue(4);
-	WRITE_DPR(pSmi, 0x00, (x1 << 16) + (y1 & 0xFFFF));
-	WRITE_DPR(pSmi, 0x04, (x2 << 16) + (y2 & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w  << 16) + (h  & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+    WaitQueue(4);
+    WRITE_DPR(pSmi, 0x00, (x1 << 16) + (y1 & 0xFFFF));
+    WRITE_DPR(pSmi, 0x04, (x2 << 16) + (y2 & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w  << 16) + (h  & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 
-	LEAVE_PROC("SMI_SubsequentScreenToScreenCopy");
+    LEAVE_PROC("SMI_SubsequentScreenToScreenCopy");
 }
 
 /******************************************************************************/
-/*								   Solid Fills								  */
+/*   Solid Fills							      */
 /******************************************************************************/
 
 static void
 SMI_SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
-					  unsigned int planemask)
+		      unsigned int planemask)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetupForSolidFill");
-	DEBUG((VERBLEV, "color=%08X rop=%02X\n", color, rop));
+    ENTER_PROC("SMI_SetupForSolidFill");
+    DEBUG((VERBLEV, "color=%08X rop=%02X\n", color, rop));
 
-	pSmi->AccelCmd = XAAGetPatternROP(rop)
-				      | SMI_BITBLT
-				      | SMI_START_ENGINE;
+    pSmi->AccelCmd = XAAGetPatternROP(rop)
+		   | SMI_BITBLT
+		   | SMI_START_ENGINE;
 
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(4);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
-	}
-	else
-	{
-		WaitQueue(3);
-	}
-	WRITE_DPR(pSmi, 0x14, color);
-	WRITE_DPR(pSmi, 0x34, 0xFFFFFFFF);
-	WRITE_DPR(pSmi, 0x38, 0xFFFFFFFF);
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(4);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    } else {
+	WaitQueue(3);
+    }
+    WRITE_DPR(pSmi, 0x14, color);
+    WRITE_DPR(pSmi, 0x34, 0xFFFFFFFF);
+    WRITE_DPR(pSmi, 0x38, 0xFFFFFFFF);
 
-	LEAVE_PROC("SMI_SetupForSolidFill");
+    LEAVE_PROC("SMI_SetupForSolidFill");
 }
 
 void
 SMI_SubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SubsequentSolidFillRect");
-	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
+    ENTER_PROC("SMI_SubsequentSolidFillRect");
+    DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
 
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x *= 3;
-		w *= 3;
+    if (pScrn->bitsPerPixel == 24) {
+	x *= 3;
+	w *= 3;
 
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
 	}
+    }
 
-	WaitQueue(3);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+    WaitQueue(3);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 
-	LEAVE_PROC("SMI_SubsequentSolidFillRect");
+    LEAVE_PROC("SMI_SubsequentSolidFillRect");
 }
 
 /******************************************************************************/
-/*								   Solid Lines								  */
+/*   Solid Lines							      */
 /******************************************************************************/
 
 static void
 SMI_SubsequentSolidHorVertLine(ScrnInfoPtr pScrn, int x, int y, int len,
 							   int dir)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int w, h;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int w, h;
 
-	ENTER_PROC("SMI_SubsequentSolidHorVertLine");
-	DEBUG((VERBLEV, "x=%d y=%d len=%d dir=%d\n", x, y, len, dir));
+    ENTER_PROC("SMI_SubsequentSolidHorVertLine");
+    DEBUG((VERBLEV, "x=%d y=%d len=%d dir=%d\n", x, y, len, dir));
 
-	if (dir == DEGREES_0)
-	{
-		w = len;
-		h = 1;
-	}
-	else
-	{
-		w = 1;
-		h = len;
-	}
+    if (dir == DEGREES_0) {
+	w = len;
+	h = 1;
+    } else {
+	w = 1;
+	h = len;
+    }
 
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x *= 3;
-		w *= 3;
+    if (pScrn->bitsPerPixel == 24) {
+	x *= 3;
+	w *= 3;
 
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
 	}
+    }
 
-	WaitQueue(3);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+    WaitQueue(3);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 
-	LEAVE_PROC("SMI_SubsequentSolidHorVertLine");
+    LEAVE_PROC("SMI_SubsequentSolidHorVertLine");
 }
 
 /******************************************************************************/
-/*							  Color Expansion Fills							  */
+/*  Color Expansion Fills						      */
 /******************************************************************************/
 
 static void
 SMI_SetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int fg, int bg,
-									   int rop, unsigned int planemask)
+				       int rop, unsigned int planemask)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetupForCPUToScreenColorExpandFill");
-	DEBUG((VERBLEV, "fg=%08X bg=%08X rop=%02X\n", fg, bg, rop));
+    ENTER_PROC("SMI_SetupForCPUToScreenColorExpandFill");
+    DEBUG((VERBLEV, "fg=%08X bg=%08X rop=%02X\n", fg, bg, rop));
 
-	pSmi->AccelCmd = XAAGetCopyROP(rop)
-				      | SMI_HOSTBLT_WRITE
-				      | SMI_SRC_MONOCHROME
-				      | SMI_START_ENGINE;
+    pSmi->AccelCmd = XAAGetCopyROP(rop)
+		   | SMI_HOSTBLT_WRITE
+		   | SMI_SRC_MONOCHROME
+		   | SMI_START_ENGINE;
 
-	if (bg == -1)
-	{
-		pSmi->AccelCmd |= SMI_TRANSPARENT_SRC;
+    if (bg == -1) {
+	pSmi->AccelCmd |= SMI_TRANSPARENT_SRC;
 
-		WaitQueue(3);
-		WRITE_DPR(pSmi, 0x14, fg);
-		WRITE_DPR(pSmi, 0x18, ~fg);
-		WRITE_DPR(pSmi, 0x20, fg);
-	}
-	else
-	{
-		WaitQueue(2);
-		WRITE_DPR(pSmi, 0x14, fg);
-		WRITE_DPR(pSmi, 0x18, bg);
-	}
+	WaitQueue(3);
+	WRITE_DPR(pSmi, 0x14, fg);
+	WRITE_DPR(pSmi, 0x18, ~fg);
+	WRITE_DPR(pSmi, 0x20, fg);
+    } else {
+	WaitQueue(2);
+	WRITE_DPR(pSmi, 0x14, fg);
+	WRITE_DPR(pSmi, 0x18, bg);
+    }
 
-	LEAVE_PROC("SMI_SetupForCPUToScreenColorExpandFill");
+    LEAVE_PROC("SMI_SetupForCPUToScreenColorExpandFill");
 }
 
 void
 SMI_SubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int x, int y, int w,
-										 int h, int skipleft)
+					 int h, int skipleft)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_SubsequentCPUToScreenColorExpandFill");
-	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d skipleft=%d\n", x, y, w, h, skipleft));
-
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x        *= 3;
-		w        *= 3;
-		skipleft *= 3;
-
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
-	}
-
-	if (skipleft)
-	{
-		WaitQueue(5);
-		WRITE_DPR(pSmi, 0x2C, (pSmi->ScissorsLeft & 0xFFFF0000)
-				| (x + skipleft) | 0x2000);
-		pSmi->ClipTurnedOn = TRUE;
-	}
-	else
-	{
-		if (pSmi->ClipTurnedOn)
-		{
-			WaitQueue(5);
-			WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-			pSmi->ClipTurnedOn = FALSE;
-		}
-		else
-		{
-			WaitQueue(4);
-		}
-	}
-	WRITE_DPR(pSmi, 0x00, 0);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
-
-	LEAVE_PROC("SMI_SubsequentCPUToScreenColorExpandFill");
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_SubsequentCPUToScreenColorExpandFill");
+    DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d skipleft=%d\n", x, y, w, h, skipleft));
+
+    if (pScrn->bitsPerPixel == 24) {
+	x        *= 3;
+	w        *= 3;
+	skipleft *= 3;
+
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
+	}
+    }
+
+    if (skipleft) {
+	WaitQueue(5);
+	WRITE_DPR(pSmi, 0x2C, (pSmi->ScissorsLeft & 0xFFFF0000)
+			      | (x + skipleft) | 0x2000);
+	pSmi->ClipTurnedOn = TRUE;
+    } else {
+	if (pSmi->ClipTurnedOn) {
+	    WaitQueue(5);
+	    WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	    pSmi->ClipTurnedOn = FALSE;
+	} else {
+	    WaitQueue(4);
+	}
+    }
+    WRITE_DPR(pSmi, 0x00, 0);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+
+    LEAVE_PROC("SMI_SubsequentCPUToScreenColorExpandFill");
 }
 
 /******************************************************************************/
-/*							 8x8 Mono Pattern Fills							  */
+/* 8x8 Mono Pattern Fills						      */
 /******************************************************************************/
 
 static void
 SMI_SetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, int fg,
-							   int bg, int rop, unsigned int planemask)
+			       int bg, int rop, unsigned int planemask)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetupForMono8x8PatternFill");
-	DEBUG((VERBLEV, "patx=%08X paty=%08X fg=%08X bg=%08X rop=%02X\n", patx,
-			paty, fg, bg, rop));
+    ENTER_PROC("SMI_SetupForMono8x8PatternFill");
+    DEBUG((VERBLEV, "patx=%08X paty=%08X fg=%08X bg=%08X rop=%02X\n", patx,
+	   paty, fg, bg, rop));
 
-	pSmi->AccelCmd = XAAGetPatternROP(rop)
-				      | SMI_BITBLT
-				      | SMI_START_ENGINE;
+    pSmi->AccelCmd = XAAGetPatternROP(rop)
+		   | SMI_BITBLT
+		   | SMI_START_ENGINE;
 
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
-	}
-
-	if (bg == -1)
-	{
-		WaitQueue(5);
-		WRITE_DPR(pSmi, 0x14, fg);
-		WRITE_DPR(pSmi, 0x18, ~fg);
-		WRITE_DPR(pSmi, 0x20, fg);
-		WRITE_DPR(pSmi, 0x34, patx);
-		WRITE_DPR(pSmi, 0x38, paty);
-	}
-	else
-	{
-		WaitQueue(4);
-		WRITE_DPR(pSmi, 0x14, fg);
-		WRITE_DPR(pSmi, 0x18, bg);
-		WRITE_DPR(pSmi, 0x34, patx);
-		WRITE_DPR(pSmi, 0x38, paty);
-	}
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    }
+
+    if (bg == -1) {
+	WaitQueue(5);
+	WRITE_DPR(pSmi, 0x14, fg);
+	WRITE_DPR(pSmi, 0x18, ~fg);
+	WRITE_DPR(pSmi, 0x20, fg);
+	WRITE_DPR(pSmi, 0x34, patx);
+	WRITE_DPR(pSmi, 0x38, paty);
+    } else {
+	WaitQueue(4);
+	WRITE_DPR(pSmi, 0x14, fg);
+	WRITE_DPR(pSmi, 0x18, bg);
+	WRITE_DPR(pSmi, 0x34, patx);
+	WRITE_DPR(pSmi, 0x38, paty);
+    }
 
-	LEAVE_PROC("SMI_SetupForMono8x8PatternFill");
+    LEAVE_PROC("SMI_SetupForMono8x8PatternFill");
 }
 
 static void
 SMI_SubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
-									 int x, int y, int w, int h)
+				     int x, int y, int w, int h)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_SubsequentMono8x8PatternFillRect");
-	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
-
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x *= 3;
-		w *= 3;
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_SubsequentMono8x8PatternFillRect");
+    DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
+
+    if (pScrn->bitsPerPixel == 24) {
+	x *= 3;
+	w *= 3;
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
 	}
+    }
 
-	WaitQueue(3);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+    WaitQueue(3);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 
-	LEAVE_PROC("SMI_SubsequentMono8x8PatternFillRect");
+    LEAVE_PROC("SMI_SubsequentMono8x8PatternFillRect");
 }
 
 /******************************************************************************/
-/*							 8x8 Color Pattern Fills						  */
+/* 8x8 Color Pattern Fills						      */
 /******************************************************************************/
 
 static void
 SMI_SetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, int rop,
-								unsigned int planemask, int trans_color)
+				unsigned int planemask, int trans_color)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_SetupForColor8x8PatternFill");
-	DEBUG((VERBLEV, "patx=%d paty=%d rop=%02X trans_color=%08X\n", patx, paty,
-			rop, trans_color));
-
-	pSmi->AccelCmd = XAAGetPatternROP(rop)
-				      | SMI_BITBLT
-				      | SMI_COLOR_PATTERN
-				      | SMI_START_ENGINE;
-
-	if (pScrn->bitsPerPixel <= 16)
-	{
-		/* PDR#950 */
-		CARD8* pattern = pSmi->FBBase
-					   + (patx + paty * pSmi->Stride) * pSmi->Bpp;
-
-		WaitIdleEmpty();
-		WRITE_DPR(pSmi, 0x0C, SMI_BITBLT | SMI_COLOR_PATTERN);
-		memcpy(pSmi->DataPortBase, pattern, 8 * pSmi->Bpp * 8);
-	}
-	else
-	{
-		if (pScrn->bitsPerPixel == 24)
-		{
-			patx *= 3;
-
-			if (pSmi->Chipset == SMI_LYNX)
-			{
-				paty *= 3;
-			}
-		}
-
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x00, (patx << 16) | (paty & 0xFFFF));
-	}
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	if (trans_color == -1)
-	{
-		pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
+    ENTER_PROC("SMI_SetupForColor8x8PatternFill");
+    DEBUG((VERBLEV, "patx=%d paty=%d rop=%02X trans_color=%08X\n", patx, paty,
+	   rop, trans_color));
 
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x20, trans_color);
-	}
+    pSmi->AccelCmd = XAAGetPatternROP(rop)
+		   | SMI_BITBLT
+		   | SMI_COLOR_PATTERN
+		   | SMI_START_ENGINE;
+
+    if (pScrn->bitsPerPixel <= 16) {
+	/* PDR#950 */
+	CARD8* pattern = pSmi->FBBase + (patx + paty * pSmi->Stride) * pSmi->Bpp;
 
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
+	WaitIdleEmpty();
+	WRITE_DPR(pSmi, 0x0C, SMI_BITBLT | SMI_COLOR_PATTERN);
+	memcpy(pSmi->DataPortBase, pattern, 8 * pSmi->Bpp * 8);
+    } else {
+	if (pScrn->bitsPerPixel == 24) {
+	    patx *= 3;
+
+	    if (pSmi->Chipset == SMI_LYNX) {
+		paty *= 3;
+	    }
 	}
 
-	LEAVE_PROC("SMI_SetupForColor8x8PatternFill");
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x00, (patx << 16) | (paty & 0xFFFF));
+    }
+
+    if (trans_color == -1) {
+	pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
+
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x20, trans_color);
+    }
+
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    }
+
+    LEAVE_PROC("SMI_SetupForColor8x8PatternFill");
 }
 
 static void
 SMI_SubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
-									  int x, int y, int w, int h)
+				      int x, int y, int w, int h)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SubsequentColor8x8PatternFillRect");
-	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
+    ENTER_PROC("SMI_SubsequentColor8x8PatternFillRect");
+    DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
 
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x *= 3;
-		w *= 3;
+    if (pScrn->bitsPerPixel == 24) {
+	x *= 3;
+	w *= 3;
 
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
 	}
+    }
 
-	WaitQueue(3);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));	/* PDR#950 */
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+    WaitQueue(3);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));	/* PDR#950 */
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 
-	LEAVE_PROC("SMI_SubsequentColor8x8PatternFillRect");
+    LEAVE_PROC("SMI_SubsequentColor8x8PatternFillRect");
 }
 
 #if SMI_USE_IMAGE_WRITES
 /******************************************************************************/
-/*								  Image Writes								  */
+/*  Image Writes							      */
 /******************************************************************************/
 
 static void
 SMI_SetupForImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
-					   int trans_color, int bpp, int depth)
+		       int trans_color, int bpp, int depth)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetupForImageWrite");
-	DEBUG((VERBLEV, "rop=%02X trans_color=%08X bpp=%d depth=%d\n", rop,
-			trans_color, bpp, depth));
+    ENTER_PROC("SMI_SetupForImageWrite");
+    DEBUG((VERBLEV, "rop=%02X trans_color=%08X bpp=%d depth=%d\n", rop,
+	   trans_color, bpp, depth));
 
-	pSmi->AccelCmd = XAAGetCopyROP(rop)
-				      | SMI_HOSTBLT_WRITE
-				      | SMI_START_ENGINE;
+    pSmi->AccelCmd = XAAGetCopyROP(rop)
+		   | SMI_HOSTBLT_WRITE
+		   | SMI_START_ENGINE;
 
-	if (trans_color != -1)
-	{
-		pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
+    if (trans_color != -1) {
+	pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
 
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x20, trans_color);
-	}
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x20, trans_color);
+    }
 
-	LEAVE_PROC("SMI_SetupForImageWrite");
+    LEAVE_PROC("SMI_SetupForImageWrite");
 }
 
 static void
 SMI_SubsequentImageWriteRect(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-							 int skipleft)
+			     int skipleft)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_SubsequentImageWriteRect");
-	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d skipleft=%d\n", x, y, w, h, skipleft));
-
-	if (pScrn->bitsPerPixel == 24)
-	{
-		x        *= 3;
-		w        *= 3;
-		skipleft *= 3;
-
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			y *= 3;
-		}
-	}
-
-	if (skipleft)
-	{
-		WaitQueue(5);
-		WRITE_DPR(pSmi, 0x2C, (pSmi->ScissorsLeft & 0xFFFF0000) |
-				(x + skipleft) | 0x2000);
-		pSmi->ClipTurnedOn = TRUE;
-	}
-	else
-	{
-		if (pSmi->ClipTurnedOn)
-		{
-			WaitQueue(5);
-			WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-			pSmi->ClipTurnedOn = FALSE;
-		}
-		else
-		{
-			WaitQueue(4);
-		}
-	}
-	WRITE_DPR(pSmi, 0x00, 0);
-	WRITE_DPR(pSmi, 0x04, (x << 16) | (y * 0xFFFF));
-	WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
-	WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
-
-	LEAVE_PROC("SMI_SubsequentImageWriteRect");
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_SubsequentImageWriteRect");
+    DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d skipleft=%d\n", x, y, w, h, skipleft));
+
+    if (pScrn->bitsPerPixel == 24) {
+	x        *= 3;
+	w        *= 3;
+	skipleft *= 3;
+
+	if (pSmi->Chipset == SMI_LYNX) {
+	    y *= 3;
+	}
+    }
+
+    if (skipleft) {
+	WaitQueue(5);
+	WRITE_DPR(pSmi, 0x2C, (pSmi->ScissorsLeft & 0xFFFF0000) |
+			      (x + skipleft) | 0x2000);
+	pSmi->ClipTurnedOn = TRUE;
+    } else {
+	if (pSmi->ClipTurnedOn) {
+	    WaitQueue(5);
+	    WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	    pSmi->ClipTurnedOn = FALSE;
+	} else {
+	    WaitQueue(4);
+	}
+    }
+    WRITE_DPR(pSmi, 0x00, 0);
+    WRITE_DPR(pSmi, 0x04, (x << 16) | (y * 0xFFFF));
+    WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
+    WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
+
+    LEAVE_PROC("SMI_SubsequentImageWriteRect");
 }
 #endif
 
 /******************************************************************************/
-/*									Clipping								  */
+/*  Clipping								      */
 /******************************************************************************/
 
 static void
 SMI_SetClippingRectangle(ScrnInfoPtr pScrn, int left, int top, int right,
-						 int bottom)
+			 int bottom)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetClippingRectangle");
-	DEBUG((VERBLEV, "left=%d top=%d right=%d bottom=%d\n", left, top, right,
-			bottom));
+    ENTER_PROC("SMI_SetClippingRectangle");
+    DEBUG((VERBLEV, "left=%d top=%d right=%d bottom=%d\n", left, top, right,
+	   bottom));
 
     /* CZ 26.10.2001: this code prevents offscreen pixmaps being drawn ???
 	left   = max(left, 0);
@@ -893,66 +813,57 @@ SMI_SetClippingRectangle(ScrnInfoPtr pScrn, int left, int top, int right,
 	bottom = min(bottom, pSmi->height);
     */
 
-	if (pScrn->bitsPerPixel == 24)
-	{
-		left  *= 3;
-		right *= 3;
+    if (pScrn->bitsPerPixel == 24) {
+	left  *= 3;
+	right *= 3;
 
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			top    *= 3;
-			bottom *= 3;
-		}
+	if (pSmi->Chipset == SMI_LYNX) {
+	    top    *= 3;
+	    bottom *= 3;
 	}
+    }
 
-	pSmi->ScissorsLeft = (top << 16) | (left & 0xFFFF) | 0x2000;
-	pSmi->ScissorsRight = (bottom << 16) | (right & 0xFFFF);
+    pSmi->ScissorsLeft = (top << 16) | (left & 0xFFFF) | 0x2000;
+    pSmi->ScissorsRight = (bottom << 16) | (right & 0xFFFF);
 
-	pSmi->ClipTurnedOn = FALSE;
+    pSmi->ClipTurnedOn = FALSE;
 
-	WaitQueue(2);
-	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-	WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
+    WaitQueue(2);
+    WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+    WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
 
-	LEAVE_PROC("SMI_SetClippingRectangle");
+    LEAVE_PROC("SMI_SetClippingRectangle");
 }
 
 static void
 SMI_DisableClipping(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_DisableClipping");
-
-	pSmi->ScissorsLeft = 0;
-	if (pScrn->bitsPerPixel == 24)
-	{
-		if (pSmi->Chipset == SMI_LYNX)
-		{
-			pSmi->ScissorsRight = ((pSmi->height * 3) << 16)
-								| (pSmi->width * 3);
-		}
-		else
-		{
-			pSmi->ScissorsRight = (pSmi->height << 16) | (pSmi->width * 3);
-		}
-	}
-	else
-	{
-		pSmi->ScissorsRight = (pSmi->height << 16) | pSmi->width;
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_DisableClipping");
+
+    pSmi->ScissorsLeft = 0;
+    if (pScrn->bitsPerPixel == 24) {
+	if (pSmi->Chipset == SMI_LYNX) {
+	    pSmi->ScissorsRight = ((pSmi->height * 3) << 16) | (pSmi->width * 3);
+	} else {
+	    pSmi->ScissorsRight = (pSmi->height << 16) | (pSmi->width * 3);
 	}
+    } else {
+	pSmi->ScissorsRight = (pSmi->height << 16) | pSmi->width;
+    }
 
-	pSmi->ClipTurnedOn = FALSE;
+    pSmi->ClipTurnedOn = FALSE;
 
-	WaitQueue(2);
-	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-	WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
+    WaitQueue(2);
+    WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+    WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
 
-	LEAVE_PROC("SMI_DisableClipping");
+    LEAVE_PROC("SMI_DisableClipping");
 }
 
 /******************************************************************************/
-/*									Polylines							 #671 */
+/*  Polylines							         #671 */
 /******************************************************************************/
 
 /*
@@ -978,142 +889,128 @@ All this code improves the speed quite a bit.
 
 #define IS_VISIBLE(pWin) \
 ( \
-	   pScrn->vtSema \
-	&& (((WindowPtr) pWin)->visibility != VisibilityFullyObscured) \
+    pScrn->vtSema \
+    && (((WindowPtr) pWin)->visibility != VisibilityFullyObscured) \
 )
 
 #define TRIM_BOX(box, pGC) \
 { \
-	BoxPtr extents = &pGC->pCompositeClip->extents; \
-	if (box.x1 < extents->x1) box.x1 = extents->x1; \
-	if (box.y1 < extents->y1) box.y1 = extents->y1; \
-	if (box.x2 > extents->x2) box.x2 = extents->x2; \
-	if (box.y2 > extents->y2) box.y2 = extents->y2; \
+    BoxPtr extents = &pGC->pCompositeClip->extents; \
+    if (box.x1 < extents->x1) box.x1 = extents->x1; \
+    if (box.y1 < extents->y1) box.y1 = extents->y1; \
+    if (box.x2 > extents->x2) box.x2 = extents->x2; \
+    if (box.y2 > extents->y2) box.y2 = extents->y2; \
 }
 
 #define TRANSLATE_BOX(box, pDraw) \
 { \
-	box.x1 += pDraw->x; \
-	box.y1 += pDraw->y; \
-	box.x2 += pDraw->x; \
-	box.y2 += pDraw->y; \
+    box.x1 += pDraw->x; \
+    box.y1 += pDraw->y; \
+    box.x2 += pDraw->x; \
+    box.y2 += pDraw->y; \
 }
 
 #define BOX_NOT_EMPTY(box) \
-	((box.x2 > box.x1) && (box.y2 > box.y1))
+    ((box.x2 > box.x1) && (box.y2 > box.y1))
 
 static void
 SMI_ValidatePolylines(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
 {
-	XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-	SMIPtr pSmi = SMIPTR(infoRec->pScrn);
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    SMIPtr pSmi = SMIPTR(infoRec->pScrn);
 
-	ENTER_PROC("SMI_ValidatePolylines");
+    ENTER_PROC("SMI_ValidatePolylines");
 
-	pSmi->ValidatePolylines(pGC, changes, pDraw);
-	if (pGC->ops->Polylines == XAAGetFallbackOps()->Polylines)
-	{
-		/* Override the Polylines function with our own Polylines function. */
-		pGC->ops->Polylines = SMI_Polylines;
-	}
+    pSmi->ValidatePolylines(pGC, changes, pDraw);
+    if (pGC->ops->Polylines == XAAGetFallbackOps()->Polylines) {
+	/* Override the Polylines function with our own Polylines function. */
+	pGC->ops->Polylines = SMI_Polylines;
+    }
 
-	LEAVE_PROC("SMI_ValidatePolylines");
+    LEAVE_PROC("SMI_ValidatePolylines");
 }
 
 static void
 SMI_Polylines(DrawablePtr pDraw, GCPtr pGC, int mode, int npt,
-			  DDXPointPtr pptInit)
+	      DDXPointPtr pptInit)
 {
-	XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-	ScrnInfoPtr pScrn = infoRec->pScrn;
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_Polylines");
-
-	/* Call the original Polylines function. */
-	pGC->ops->Polylines = XAAGetFallbackOps()->Polylines;
-	(*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
-	pGC->ops->Polylines = SMI_Polylines;
-
-	if (IS_VISIBLE(pDraw) && npt)
-	{
-		/* Allocate a temporary buffer for all segments of the polyline. */
-		BoxPtr pBox = xnfcalloc(sizeof(BoxRec), npt);
-		int extra = pGC->lineWidth >> 1, box;
-
-		if (npt > 1)
-		{
-			/* Adjust the extra space required per polyline segment. */
-			if (pGC->joinStyle == JoinMiter)
-			{
-				extra = 6 * pGC->lineWidth;
-			}
-			else if (pGC->capStyle == CapProjecting)
-			{
-				extra = pGC->lineWidth;
-			}
-		}
-
-		for (box = 0; --npt;)
-		{
-			/* Setup the bounding box for one polyline segment. */
-			pBox[box].x1 = pptInit->x;
-			pBox[box].y1 = pptInit->y;
-			pptInit++;
-			pBox[box].x2 = pptInit->x;
-			pBox[box].y2 = pptInit->y;
-			if (mode == CoordModePrevious)
-			{
-				pBox[box].x2 += pBox[box].x1;
-				pBox[box].y2 += pBox[box].y1;
-			}
-
-			/* Sort coordinates. */
-			if (pBox[box].x1 > pBox[box].x2)
-			{
-				int tmp = pBox[box].x1;
-				pBox[box].x1 = pBox[box].x2;
-				pBox[box].x2 = tmp;
-			}
-			if (pBox[box].y1 > pBox[box].y2)
-			{
-				int tmp = pBox[box].y1;
-				pBox[box].y1 = pBox[box].y2;
-				pBox[box].y2 = tmp;
-			}
-
-			/* Add extra space required for each polyline segment. */
-			pBox[box].x1 -= extra;
-			pBox[box].y1 -= extra;
-			pBox[box].x2 += extra + 1;
-			pBox[box].y2 += extra + 1;
-
-			/* See if we need to draw this polyline segment. */
-			TRANSLATE_BOX(pBox[box], pDraw);
-			TRIM_BOX(pBox[box], pGC);
-			if (BOX_NOT_EMPTY(pBox[box]))
-			{
-				box++;
-			}
-		}
-
-		if (box)
-		{
-			/* Refresh all polyline segments now. */
-			if (pSmi->Chipset == SMI_COUGAR3DR)
-			{
-				SMI_RefreshArea730(pScrn, box, pBox);
-			}
-			else
-			{
-				SMI_RefreshArea(pScrn, box, pBox);
-			}
-		}
-
-		/* Free the temporary buffer. */
-		xfree(pBox);
-	}
-
-	pSmi->polyLines = TRUE;
-	LEAVE_PROC("SMI_Polylines");
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    ScrnInfoPtr pScrn = infoRec->pScrn;
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_Polylines");
+
+    /* Call the original Polylines function. */
+    pGC->ops->Polylines = XAAGetFallbackOps()->Polylines;
+    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
+    pGC->ops->Polylines = SMI_Polylines;
+
+    if (IS_VISIBLE(pDraw) && npt) {
+	/* Allocate a temporary buffer for all segments of the polyline. */
+	BoxPtr pBox = xnfcalloc(sizeof(BoxRec), npt);
+	int extra = pGC->lineWidth >> 1, box;
+
+	if (npt > 1) {
+	    /* Adjust the extra space required per polyline segment. */
+	    if (pGC->joinStyle == JoinMiter) {
+		extra = 6 * pGC->lineWidth;
+	    } else if (pGC->capStyle == CapProjecting) {
+		extra = pGC->lineWidth;
+	    }
+	}
+
+	for (box = 0; --npt;) {
+	    /* Setup the bounding box for one polyline segment. */
+	    pBox[box].x1 = pptInit->x;
+	    pBox[box].y1 = pptInit->y;
+	    pptInit++;
+	    pBox[box].x2 = pptInit->x;
+	    pBox[box].y2 = pptInit->y;
+	    if (mode == CoordModePrevious) {
+		pBox[box].x2 += pBox[box].x1;
+		pBox[box].y2 += pBox[box].y1;
+	    }
+
+	    /* Sort coordinates. */
+	    if (pBox[box].x1 > pBox[box].x2) {
+		int tmp = pBox[box].x1;
+		pBox[box].x1 = pBox[box].x2;
+		pBox[box].x2 = tmp;
+	    }
+	    if (pBox[box].y1 > pBox[box].y2) {
+		int tmp = pBox[box].y1;
+		pBox[box].y1 = pBox[box].y2;
+		pBox[box].y2 = tmp;
+	    }
+
+	    /* Add extra space required for each polyline segment. */
+	    pBox[box].x1 -= extra;
+	    pBox[box].y1 -= extra;
+	    pBox[box].x2 += extra + 1;
+	    pBox[box].y2 += extra + 1;
+
+	    /* See if we need to draw this polyline segment. */
+	    TRANSLATE_BOX(pBox[box], pDraw);
+	    TRIM_BOX(pBox[box], pGC);
+	    if (BOX_NOT_EMPTY(pBox[box])) {
+		box++;
+	    }
+	}
+
+	if (box) {
+	    /* Refresh all polyline segments now. */
+	    if (pSmi->Chipset == SMI_COUGAR3DR) {
+		SMI_RefreshArea730(pScrn, box, pBox);
+	    } else {
+		SMI_RefreshArea(pScrn, box, pBox);
+	    }
+	}
+
+	/* Free the temporary buffer. */
+	xfree(pBox);
+    }
+
+    pSmi->polyLines = TRUE;
+    LEAVE_PROC("SMI_Polylines");
 }
+
diff --git a/src/smi_dac.c b/src/smi_dac.c
index 7489ddd..1df1cbf 100644
--- a/src/smi_dac.c
+++ b/src/smi_dac.c
@@ -41,63 +41,56 @@ SMI_CommonCalcClock(int scrnIndex, long freq, int min_m, int min_n1,
 		    int max_n1, int min_n2, int max_n2, long freq_min, 
 		    long freq_max, unsigned char *mdiv, unsigned char *ndiv)
 {
-	double div, diff, best_diff;
-	unsigned int m;
-	unsigned char n1, n2;
-	unsigned char best_n1 = 63, best_n2 = 3, best_m = 255;
-
-	double ffreq     = freq     / 1000.0 / BASE_FREQ;
-	double ffreq_min = freq_min / 1000.0 / BASE_FREQ;
-	double ffreq_max = freq_max / 1000.0 / BASE_FREQ;
-
-	if (ffreq < ffreq_min / (1 << max_n2))
-	{
-		xf86DrvMsg(scrnIndex,X_WARNING,"invalid frequency %1.3f MHz  [freq >= %1.3f MHz]\n",
-				ffreq * BASE_FREQ, ffreq_min * BASE_FREQ / (1 << max_n2));
-		ffreq = ffreq_min / (1 << max_n2);
-	}
-	if (ffreq > ffreq_max / (1 << min_n2))
-	{
-		xf86DrvMsg(scrnIndex,X_WARNING,"invalid frequency %1.3f MHz  [freq <= %1.3f MHz]\n",
-				ffreq * BASE_FREQ, ffreq_max * BASE_FREQ / (1 << min_n2));
-		ffreq = ffreq_max / (1 << min_n2);
-	}
+    double div, diff, best_diff;
+    unsigned int m;
+    unsigned char n1, n2;
+    unsigned char best_n1 = 63, best_n2 = 3, best_m = 255;
+
+    double ffreq     = freq     / 1000.0 / BASE_FREQ;
+    double ffreq_min = freq_min / 1000.0 / BASE_FREQ;
+    double ffreq_max = freq_max / 1000.0 / BASE_FREQ;
+
+    if (ffreq < ffreq_min / (1 << max_n2)) {
+	xf86DrvMsg(scrnIndex,X_WARNING,"invalid frequency %1.3f MHz  [freq >= %1.3f MHz]\n",
+		ffreq * BASE_FREQ, ffreq_min * BASE_FREQ / (1 << max_n2));
+	ffreq = ffreq_min / (1 << max_n2);
+    }
+    if (ffreq > ffreq_max / (1 << min_n2)) {
+	xf86DrvMsg(scrnIndex,X_WARNING,"invalid frequency %1.3f MHz  [freq <= %1.3f MHz]\n",
+		ffreq * BASE_FREQ, ffreq_max * BASE_FREQ / (1 << min_n2));
+	ffreq = ffreq_max / (1 << min_n2);
+    }
 
-	/* work out suitable timings */
-	best_diff = ffreq;
-
-	for (n2 = min_n2; n2 <= max_n2; n2++)
-	{
-		for (n1 = min_n1; n1 <= max_n1; n1++)
-		{
-			m = (int)(ffreq * n1 * (1 << n2) + 0.5);
-			if ( (m < min_m) || (m > 255) )
-			{
-				continue;
-			}
-			div = (double)(m) / (double)(n1);
-			if ( (div >= ffreq_min) && (div <= ffreq_max) )
-			{
-				diff = ffreq - div / (1 << n2);
-				if (diff < 0.0)
-				{
-					diff = -diff;
-				}
-				if (diff < best_diff)
-				{
-					best_diff = diff;
-					best_m    = m;
-					best_n1   = n1;
-					best_n2   = n2;
-				}
-			}
+    /* work out suitable timings */
+    best_diff = ffreq;
+
+    for (n2 = min_n2; n2 <= max_n2; n2++) {
+	for (n1 = min_n1; n1 <= max_n1; n1++) {
+	    m = (int)(ffreq * n1 * (1 << n2) + 0.5);
+	    if ( (m < min_m) || (m > 255) ) {
+		continue;
+	    }
+	    div = (double)(m) / (double)(n1);
+	    if ( (div >= ffreq_min) && (div <= ffreq_max) ) {
+		diff = ffreq - div / (1 << n2);
+		if (diff < 0.0) {
+		    diff = -diff;
+		}
+		if (diff < best_diff) {
+		    best_diff = diff;
+		    best_m    = m;
+		    best_n1   = n1;
+		    best_n2   = n2;
 		}
+	    }
 	}
+    }
 
-	DEBUG((VERBLEV, "Clock parameters for %1.6f MHz: m=%d, n1=%d, n2=%d\n",
-			((double)(best_m) / (double)(best_n1) / (1 << best_n2)) * BASE_FREQ,
-			best_m, best_n1, best_n2));
+    DEBUG((VERBLEV, "Clock parameters for %1.6f MHz: m=%d, n1=%d, n2=%d\n",
+	 ((double)(best_m) / (double)(best_n1) / (1 << best_n2)) * BASE_FREQ,
+	 best_m, best_n1, best_n2));
 
-	*ndiv = best_n1 | (best_n2 << 6);
-	*mdiv = best_m;
+    *ndiv = best_n1 | (best_n2 << 6);
+    *mdiv = best_m;
 }
+
diff --git a/src/smi_dga.c b/src/smi_dga.c
index 3fd0864..71d0922 100644
--- a/src/smi_dga.c
+++ b/src/smi_dga.c
@@ -55,145 +55,132 @@ static void SMI_BlitTransRect(ScrnInfoPtr, int, int, int, int, int, int,
 static
 DGAFunctionRec SMI_DGAFuncs =
 {
-   SMI_OpenFramebuffer,
-   NULL,
-   SMI_SetMode,
-   SMI_SetViewport,
-   SMI_GetViewport,
-   SMI_AccelSync,
-   SMI_FillRect,
-   SMI_BlitRect,
-   SMI_BlitTransRect
+    SMI_OpenFramebuffer,
+    NULL,
+    SMI_SetMode,
+    SMI_SetViewport,
+    SMI_GetViewport,
+    SMI_AccelSync,
+    SMI_FillRect,
+    SMI_BlitRect,
+    SMI_BlitTransRect
 };
 
 Bool
 SMI_DGAInit(ScreenPtr pScreen)
 {
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	DGAModePtr modes = NULL, newmodes = NULL, currentMode;
-	DisplayModePtr pMode, firstMode;
-	int Bpp = pScrn->bitsPerPixel >> 3;
-	int num = 0;
-	Bool ret;
-
-	ENTER_PROC("SMI_DGAInit");
-
-	pMode = firstMode = pScrn->modes;
-
-	while (pMode)
-	{
-		newmodes = xrealloc(modes, (num + 1) * sizeof(DGAModeRec));
-		if (newmodes == NULL)
-		{
-			xfree(modes);
-			LEAVE_PROC("SMI_DGAInit");
-			return(FALSE);
-		}
-
-		modes = newmodes;
-
-		currentMode = modes + num;
-		num++;
-
-		currentMode->mode  = pMode;
-		currentMode->flags = DGA_PIXMAP_AVAILABLE;
-		if (!pSmi->NoAccel)
-		{
-			currentMode->flags |= DGA_FILL_RECT
-							   |  DGA_BLIT_RECT
-							   |  DGA_BLIT_RECT_TRANS;
-		}
-		if (pMode->Flags & V_DBLSCAN)
-		{
-			currentMode->flags |= DGA_DOUBLESCAN;
-		}
-		if (pMode->Flags & V_INTERLACE)
-		{
-			currentMode->flags |= DGA_INTERLACED;
-		}
-
-		currentMode->byteOrder      = pScrn->imageByteOrder;
-		currentMode->depth          = pScrn->depth;
-		currentMode->bitsPerPixel   = pScrn->bitsPerPixel;
-		currentMode->red_mask       = pScrn->mask.red;
-		currentMode->green_mask     = pScrn->mask.green;
-		currentMode->blue_mask      = pScrn->mask.blue;
-		currentMode->visualClass    = (Bpp == 1) ? PseudoColor : TrueColor;
-		currentMode->viewportWidth  = pMode->HDisplay;
-		currentMode->viewportHeight = pMode->VDisplay;
-		currentMode->xViewportStep  = (Bpp == 3) ? 8 : (8 / Bpp);
-		currentMode->yViewportStep  = 1;
-		currentMode->viewportFlags  = DGA_FLIP_RETRACE;
-		currentMode->offset         = 0;
-		currentMode->address        = pSmi->FBBase;
-
-		xf86ErrorFVerb(VERBLEV, "\tSMI_DGAInit %dx%d @ %d bpp\n",
-				currentMode->viewportWidth, currentMode->viewportHeight,
-				currentMode->bitsPerPixel);
-
-		currentMode->bytesPerScanline = ((pScrn->displayWidth * Bpp) + 15)
-									  & ~15L;
-		currentMode->imageWidth       = pScrn->displayWidth;
-		currentMode->imageHeight      = pSmi->FBReserved
-									  / currentMode->bytesPerScanline;
-	    currentMode->pixmapWidth      = currentMode->imageWidth;
-	    currentMode->pixmapHeight     = currentMode->imageHeight;
-	    currentMode->maxViewportX     = currentMode->imageWidth
-	    							  - currentMode->viewportWidth;
-	    currentMode->maxViewportY     = currentMode->imageHeight
-	    							  - currentMode->viewportHeight;
-
-		pMode = pMode->next;
-		if (pMode == firstMode)
-		{
-			break;
-		}
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    DGAModePtr modes = NULL, newmodes = NULL, currentMode;
+    DisplayModePtr pMode, firstMode;
+    int Bpp = pScrn->bitsPerPixel >> 3;
+    int num = 0;
+    Bool ret;
+
+    ENTER_PROC("SMI_DGAInit");
+
+    pMode = firstMode = pScrn->modes;
+
+    while (pMode) {
+	newmodes = xrealloc(modes, (num + 1) * sizeof(DGAModeRec));
+	if (newmodes == NULL) {
+	    xfree(modes);
+	    LEAVE_PROC("SMI_DGAInit");
+	    return FALSE;
 	}
 
-	pSmi->numDGAModes = num;
-	pSmi->DGAModes    = modes;
+	modes = newmodes;
+
+	currentMode = modes + num;
+	num++;
+
+	currentMode->mode  = pMode;
+	currentMode->flags = DGA_PIXMAP_AVAILABLE;
+	if (!pSmi->NoAccel) {
+	    currentMode->flags |= DGA_FILL_RECT
+			       |  DGA_BLIT_RECT
+			       |  DGA_BLIT_RECT_TRANS;
+	}
+	if (pMode->Flags & V_DBLSCAN) {
+	    currentMode->flags |= DGA_DOUBLESCAN;
+	}
+	if (pMode->Flags & V_INTERLACE) {
+	    currentMode->flags |= DGA_INTERLACED;
+	}
 
-	ret = DGAInit(pScreen, &SMI_DGAFuncs, modes, num);
-	LEAVE_PROC("SMI_DGAInit");
-	return(ret);
+	currentMode->byteOrder      = pScrn->imageByteOrder;
+	currentMode->depth          = pScrn->depth;
+	currentMode->bitsPerPixel   = pScrn->bitsPerPixel;
+	currentMode->red_mask       = pScrn->mask.red;
+	currentMode->green_mask     = pScrn->mask.green;
+	currentMode->blue_mask      = pScrn->mask.blue;
+	currentMode->visualClass    = (Bpp == 1) ? PseudoColor : TrueColor;
+	currentMode->viewportWidth  = pMode->HDisplay;
+	currentMode->viewportHeight = pMode->VDisplay;
+	currentMode->xViewportStep  = (Bpp == 3) ? 8 : (8 / Bpp);
+	currentMode->yViewportStep  = 1;
+	currentMode->viewportFlags  = DGA_FLIP_RETRACE;
+	currentMode->offset         = 0;
+	currentMode->address        = pSmi->FBBase;
+
+	xf86ErrorFVerb(VERBLEV, "\tSMI_DGAInit %dx%d @ %d bpp\n",
+			currentMode->viewportWidth, currentMode->viewportHeight,
+			currentMode->bitsPerPixel);
+
+	currentMode->bytesPerScanline = ((pScrn->displayWidth * Bpp) + 15) & ~15L;
+	currentMode->imageWidth       = pScrn->displayWidth;
+	currentMode->imageHeight      = pSmi->FBReserved / currentMode->bytesPerScanline;
+	currentMode->pixmapWidth      = currentMode->imageWidth;
+	currentMode->pixmapHeight     = currentMode->imageHeight;
+	currentMode->maxViewportX     = currentMode->imageWidth - currentMode->viewportWidth;
+	currentMode->maxViewportY     = currentMode->imageHeight - currentMode->viewportHeight;
+
+	pMode = pMode->next;
+	if (pMode == firstMode) {
+	    break;
+	}
+    }
+
+    pSmi->numDGAModes = num;
+    pSmi->DGAModes    = modes;
+
+    ret = DGAInit(pScreen, &SMI_DGAFuncs, modes, num);
+    LEAVE_PROC("SMI_DGAInit");
+    return ret;
 }
 
 static Bool
 SMI_SetMode(ScrnInfoPtr pScrn, DGAModePtr pMode)
 {
-	static int OldDisplayWidth[MAXSCREENS];
-	int index = pScrn->pScreen->myNum;
-	SMIPtr pSmi = SMIPTR(pScrn);
+    static int OldDisplayWidth[MAXSCREENS];
+    int index = pScrn->pScreen->myNum;
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetMode");
+    ENTER_PROC("SMI_SetMode");
 
-	if (pMode == NULL)
-	{	/* restore the original mode */
+    if (pMode == NULL) {
+	/* restore the original mode */
 
-		/* put the ScreenParameters back */
-		pScrn->displayWidth = OldDisplayWidth[index];
+	/* put the ScreenParameters back */
+	pScrn->displayWidth = OldDisplayWidth[index];
 
-		SMI_SwitchMode(index, pScrn->currentMode, 0);
-		pSmi->DGAactive = FALSE;
-	}
-	else
-	{
-		if (!pSmi->DGAactive)
-		{	/* save the old parameters */
-			OldDisplayWidth[index] = pScrn->displayWidth;
+	SMI_SwitchMode(index, pScrn->currentMode, 0);
+	pSmi->DGAactive = FALSE;
+    } else {
+	if (!pSmi->DGAactive) {
+	    /* save the old parameters */
+	    OldDisplayWidth[index] = pScrn->displayWidth;
 
-			pSmi->DGAactive = TRUE;
-		}
+	    pSmi->DGAactive = TRUE;
+	}
 
-		pScrn->displayWidth = pMode->bytesPerScanline
-							/ (pMode->bitsPerPixel >> 3);
+	pScrn->displayWidth = pMode->bytesPerScanline / (pMode->bitsPerPixel >> 3);
 
-		SMI_SwitchMode(index, pMode->mode, 0);
-	}
+	SMI_SwitchMode(index, pMode->mode, 0);
+    }
 
-	LEAVE_PROC("SMI_SetMode");
-	return(TRUE);
+    LEAVE_PROC("SMI_SetMode");
+    return TRUE;
 }
 
 
@@ -202,103 +189,97 @@ SMI_GetViewport(ScrnInfoPtr pScrn)
 {
     SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_GetViewport");
+    ENTER_PROC("SMI_GetViewport");
 
-	LEAVE_PROC("SMI_GetViewport");
+    LEAVE_PROC("SMI_GetViewport");
 
-    return(pSmi->DGAViewportStatus);
+    return pSmi->DGAViewportStatus;
 }
 
 static void
 SMI_SetViewport(ScrnInfoPtr pScrn, int x, int y, int flags)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetViewport");
+    ENTER_PROC("SMI_SetViewport");
 
-	SMI_AdjustFrame(pScrn->pScreen->myNum, x, y, flags);
-	pSmi->DGAViewportStatus = 0;
+    SMI_AdjustFrame(pScrn->pScreen->myNum, x, y, flags);
+    pSmi->DGAViewportStatus = 0;
 
-	LEAVE_PROC("SMI_SetViewport");
+    LEAVE_PROC("SMI_SetViewport");
 }
 
 static void
 SMI_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_FillRect");
+    ENTER_PROC("SMI_FillRect");
 
-	if (pSmi->AccelInfoRec)
-	{
-		(*pSmi->AccelInfoRec->SetupForSolidFill)(pScrn, color, GXcopy, ~0);
-		(*pSmi->AccelInfoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
-		SET_SYNC_FLAG(pSmi->AccelInfoRec);
-	}
+    if (pSmi->AccelInfoRec) {
+	(*pSmi->AccelInfoRec->SetupForSolidFill)(pScrn, color, GXcopy, ~0);
+	(*pSmi->AccelInfoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
+	SET_SYNC_FLAG(pSmi->AccelInfoRec);
+    }
 
-	LEAVE_PROC("SMI_FillRect");
+    LEAVE_PROC("SMI_FillRect");
 }
 
 static void
 SMI_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy, int w, int h, int dstx,
-			 int dsty)
+	     int dsty)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_BlitRect");
+    ENTER_PROC("SMI_BlitRect");
 
-    if (pSmi->AccelInfoRec)
-    {
-		int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
-		int ydir = (srcy < dsty) ? -1 : 1;
+    if (pSmi->AccelInfoRec) {
+	int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+	int ydir = (srcy < dsty) ? -1 : 1;
 
-		(*pSmi->AccelInfoRec->SetupForScreenToScreenCopy)(pScrn, xdir, ydir,
-														  GXcopy, ~0, -1);
-		(*pSmi->AccelInfoRec->SubsequentScreenToScreenCopy)(pScrn, srcx, srcy,
-															dstx, dsty, w, h);
-		SET_SYNC_FLAG(pSmi->AccelInfoRec);
-	}
+	(*pSmi->AccelInfoRec->SetupForScreenToScreenCopy)(pScrn, xdir, ydir, GXcopy, ~0, -1);
+	(*pSmi->AccelInfoRec->SubsequentScreenToScreenCopy)(pScrn, srcx, srcy, dstx, dsty, w, h);
+	SET_SYNC_FLAG(pSmi->AccelInfoRec);
+    }
 
-	LEAVE_PROC("SMI_BlitRect");
+    LEAVE_PROC("SMI_BlitRect");
 }
 
 static void
 SMI_BlitTransRect(ScrnInfoPtr pScrn, int srcx, int srcy, int w, int h, int dstx,
-				  int dsty, unsigned long color)
+		  int dsty, unsigned long color)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_BlitTraneRect");
+    ENTER_PROC("SMI_BlitTraneRect");
 
-	if (pSmi->AccelInfoRec)
-	{
-		int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
-		int ydir = (srcy < dsty) ? -1 : 1;
+    if (pSmi->AccelInfoRec) {
+	int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+	int ydir = (srcy < dsty) ? -1 : 1;
 
-		(*pSmi->AccelInfoRec->SetupForScreenToScreenCopy)(pScrn, xdir, ydir,
-														  GXcopy, ~0, color);
-		(*pSmi->AccelInfoRec->SubsequentScreenToScreenCopy)(pScrn, srcx, srcy,
-															dstx, dsty, w, h);
-		SET_SYNC_FLAG(pSmi->AccelInfoRec);
-	}
+	(*pSmi->AccelInfoRec->SetupForScreenToScreenCopy)(pScrn, xdir, ydir, GXcopy, ~0, color);
+	(*pSmi->AccelInfoRec->SubsequentScreenToScreenCopy)(pScrn, srcx, srcy, dstx, dsty, w, h);
+	SET_SYNC_FLAG(pSmi->AccelInfoRec);
+    }
 
-	LEAVE_PROC("SMI_BlitTraneRect");
+    LEAVE_PROC("SMI_BlitTraneRect");
 }
 
 static Bool
 SMI_OpenFramebuffer(ScrnInfoPtr pScrn, char **name, unsigned char **mem,
-					int *size, int *offset, int *flags)
+		    int *size, int *offset, int *flags)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_OpenFrameBuffer");
+    ENTER_PROC("SMI_OpenFrameBuffer");
 
-	*name   = NULL;	/* no special device */
-	*mem    = (unsigned char*)pSmi->FBBase;
-	*size   = pSmi->videoRAMBytes;
-	*offset = 0;
-	*flags  = DGA_NEED_ROOT;
+    *name   = NULL;	/* no special device */
+    *mem    = (unsigned char*)pSmi->FBBase;
+    *size   = pSmi->videoRAMBytes;
+    *offset = 0;
+    *flags  = DGA_NEED_ROOT;
 
-	LEAVE_PROC("SMI_OpenFrameBuffer");
-	return(TRUE);
+    LEAVE_PROC("SMI_OpenFrameBuffer");
+    return TRUE;
 }
+
diff --git a/src/smi_driver.c b/src/smi_driver.c
index f13b5c4..09437d9 100644
--- a/src/smi_driver.c
+++ b/src/smi_driver.c
@@ -107,90 +107,89 @@ static void SMI_DetectPanelSize(ScrnInfoPtr pScrn);
 
 _X_EXPORT DriverRec SILICONMOTION =
 {
-	SILICONMOTION_DRIVER_VERSION,
-	SILICONMOTION_DRIVER_NAME,
-	SMI_Identify,
-	SMI_Probe,
-	SMI_AvailableOptions,
-	NULL,
-	0
+    SILICONMOTION_DRIVER_VERSION,
+    SILICONMOTION_DRIVER_NAME,
+    SMI_Identify,
+    SMI_Probe,
+    SMI_AvailableOptions,
+    NULL,
+    0
 };
 
 /* Supported chipsets */
 static SymTabRec SMIChipsets[] =
 {
-	{ PCI_CHIP_SMI910, "Lynx"    },
-	{ PCI_CHIP_SMI810, "LynxE"   },
-	{ PCI_CHIP_SMI820, "Lynx3D"  },
-	{ PCI_CHIP_SMI710, "LynxEM"  },
-	{ PCI_CHIP_SMI712, "LynxEM+" },
-	{ PCI_CHIP_SMI720, "Lynx3DM" },
-	{ PCI_CHIP_SMI731, "Cougar3DR" },
-	{ -1,             NULL      }
+    { PCI_CHIP_SMI910, "Lynx"    },
+    { PCI_CHIP_SMI810, "LynxE"   },
+    { PCI_CHIP_SMI820, "Lynx3D"  },
+    { PCI_CHIP_SMI710, "LynxEM"  },
+    { PCI_CHIP_SMI712, "LynxEM+" },
+    { PCI_CHIP_SMI720, "Lynx3DM" },
+    { PCI_CHIP_SMI731, "Cougar3DR" },
+    { -1,             NULL      }
 };
 
 static PciChipsets SMIPciChipsets[] =
 {
-	/* numChipset,		PciID,				Resource */
-	{ PCI_CHIP_SMI910,	PCI_CHIP_SMI910,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI810,	PCI_CHIP_SMI810,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI820,	PCI_CHIP_SMI820,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI710,	PCI_CHIP_SMI710,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI712,	PCI_CHIP_SMI712,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI720,	PCI_CHIP_SMI720,	RES_SHARED_VGA },
-	{ PCI_CHIP_SMI731,	PCI_CHIP_SMI731,	RES_SHARED_VGA },
-	{ -1,				-1,					RES_UNDEFINED  }
+    /* numChipset,		PciID,				Resource */
+    { PCI_CHIP_SMI910,	PCI_CHIP_SMI910,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI810,	PCI_CHIP_SMI810,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI820,	PCI_CHIP_SMI820,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI710,	PCI_CHIP_SMI710,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI712,	PCI_CHIP_SMI712,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI720,	PCI_CHIP_SMI720,	RES_SHARED_VGA },
+    { PCI_CHIP_SMI731,	PCI_CHIP_SMI731,	RES_SHARED_VGA },
+    { -1,				-1,					RES_UNDEFINED  }
 };
 
 typedef enum
 {
-	OPTION_PCI_BURST,
-	OPTION_FIFO_CONSERV,
-	OPTION_FIFO_MODERATE,
-	OPTION_FIFO_AGGRESSIVE,
-	OPTION_PCI_RETRY,
-	OPTION_NOACCEL,
-	OPTION_MCLK,
-	OPTION_SHOWCACHE,
-	OPTION_SWCURSOR,
-	OPTION_HWCURSOR,
-	OPTION_SHADOW_FB,
-	OPTION_ROTATE,
-	OPTION_VIDEOKEY,
-	OPTION_BYTESWAP,
-	/* CZ 26.10.2001: interlaced video */
-	OPTION_INTERLACED,
-	/* end CZ */
-	OPTION_USEBIOS,
-	OPTION_ZOOMONLCD,
-	OPTION_DUALHEAD,
-	NUMBER_OF_OPTIONS
-
+    OPTION_PCI_BURST,
+    OPTION_FIFO_CONSERV,
+    OPTION_FIFO_MODERATE,
+    OPTION_FIFO_AGGRESSIVE,
+    OPTION_PCI_RETRY,
+    OPTION_NOACCEL,
+    OPTION_MCLK,
+    OPTION_SHOWCACHE,
+    OPTION_SWCURSOR,
+    OPTION_HWCURSOR,
+    OPTION_SHADOW_FB,
+    OPTION_ROTATE,
+    OPTION_VIDEOKEY,
+    OPTION_BYTESWAP,
+    /* CZ 26.10.2001: interlaced video */
+    OPTION_INTERLACED,
+    /* end CZ */
+    OPTION_USEBIOS,
+    OPTION_ZOOMONLCD,
+    OPTION_DUALHEAD,
+    NUMBER_OF_OPTIONS
 } SMIOpts;
 
 static const OptionInfoRec SMIOptions[] =
 {
-   { OPTION_PCI_BURST,	     "pci_burst",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_FIFO_CONSERV,    "fifo_conservative", OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_FIFO_MODERATE,   "fifo_moderate",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_FIFO_AGGRESSIVE, "fifo_aggressive",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_PCI_RETRY,	     "pci_retry",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_NOACCEL,	     "NoAccel",		  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_MCLK,	     "set_mclk",	  OPTV_FREQ,	{0}, FALSE },
-   { OPTION_SHOWCACHE,	     "show_cache",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_HWCURSOR,	     "HWCursor",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_SWCURSOR,	     "SWCursor",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_SHADOW_FB,	     "ShadowFB",	  OPTV_BOOLEAN, {0}, FALSE },
-   { OPTION_ROTATE,	     "Rotate",		  OPTV_ANYSTR,  {0}, FALSE },
-   { OPTION_VIDEOKEY,	     "VideoKey",	  OPTV_INTEGER, {0}, FALSE },
-   { OPTION_BYTESWAP,	     "ByteSwap",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_PCI_BURST,	     "pci_burst",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_FIFO_CONSERV,    "fifo_conservative", OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_FIFO_MODERATE,   "fifo_moderate",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_FIFO_AGGRESSIVE, "fifo_aggressive",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_PCI_RETRY,	     "pci_retry",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_NOACCEL,	     "NoAccel",		  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_MCLK,	     "set_mclk",	  OPTV_FREQ,	{0}, FALSE },
+    { OPTION_SHOWCACHE,	     "show_cache",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_HWCURSOR,	     "HWCursor",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_SWCURSOR,	     "SWCursor",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_SHADOW_FB,	     "ShadowFB",	  OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_ROTATE,	     "Rotate",		  OPTV_ANYSTR,  {0}, FALSE },
+    { OPTION_VIDEOKEY,	     "VideoKey",	  OPTV_INTEGER, {0}, FALSE },
+    { OPTION_BYTESWAP,	     "ByteSwap",	  OPTV_BOOLEAN, {0}, FALSE },
     /* CZ 26.10.2001: interlaced video */
-   { OPTION_INTERLACED,	     "Interlaced",        OPTV_BOOLEAN, {0}, FALSE },
-   /* end CZ */
-   { OPTION_USEBIOS,	     "UseBIOS",		  OPTV_BOOLEAN,	{0}, FALSE },
-   { OPTION_ZOOMONLCD,	     "ZoomOnLCD",	  OPTV_BOOLEAN,	{0}, FALSE },
-   { OPTION_DUALHEAD,	     "Dualhead",	  OPTV_BOOLEAN,	{0}, FALSE },
-   { -1,		     NULL,		  OPTV_NONE,	{0}, FALSE }
+    { OPTION_INTERLACED,	     "Interlaced",        OPTV_BOOLEAN, {0}, FALSE },
+    /* end CZ */
+    { OPTION_USEBIOS,	     "UseBIOS",		  OPTV_BOOLEAN,	{0}, FALSE },
+    { OPTION_ZOOMONLCD,	     "ZoomOnLCD",	  OPTV_BOOLEAN,	{0}, FALSE },
+    { OPTION_DUALHEAD,	     "Dualhead",	  OPTV_BOOLEAN,	{0}, FALSE },
+    { -1,		     NULL,		  OPTV_NONE,	{0}, FALSE }
 };
 
 /*
@@ -204,92 +203,92 @@ static const OptionInfoRec SMIOptions[] =
 
 static const char *vgahwSymbols[] =
 {
-	"vgaHWCopyReg",
-	"vgaHWGetHWRec",
-	"vgaHWGetIOBase",
-	"vgaHWGetIndex",
-	"vgaHWInit",
-	"vgaHWLock",
-	"vgaHWMapMem",
-	"vgaHWProtect",
-	"vgaHWRestore",
-	"vgaHWSave",
-	"vgaHWSaveScreen",
-	"vgaHWSetMmioFuncs",
-	"vgaHWSetStdFuncs",
-	"vgaHWUnmapMem",
-	"vgaHWddc1SetSpeedWeak",
-	NULL
+    "vgaHWCopyReg",
+    "vgaHWGetHWRec",
+    "vgaHWGetIOBase",
+    "vgaHWGetIndex",
+    "vgaHWInit",
+    "vgaHWLock",
+    "vgaHWMapMem",
+    "vgaHWProtect",
+    "vgaHWRestore",
+    "vgaHWSave",
+    "vgaHWSaveScreen",
+    "vgaHWSetMmioFuncs",
+    "vgaHWSetStdFuncs",
+    "vgaHWUnmapMem",
+    "vgaHWddc1SetSpeedWeak",
+    NULL
 };
 
 static const char *xaaSymbols[] =
 {
-	"XAAGetCopyROP",
-	"XAACreateInfoRec",
-	"XAADestroyInfoRec",
-	"XAAGetFallbackOps",
-	"XAAInit",
-	"XAAGetPatternROP",
-	NULL
+    "XAAGetCopyROP",
+    "XAACreateInfoRec",
+    "XAADestroyInfoRec",
+    "XAAGetFallbackOps",
+    "XAAInit",
+    "XAAGetPatternROP",
+    NULL
 };
 
 static const char *ramdacSymbols[] =
 {
-	"xf86CreateCursorInfoRec",
-	"xf86DestroyCursorInfoRec",
-	"xf86InitCursor",
-	NULL
+    "xf86CreateCursorInfoRec",
+    "xf86DestroyCursorInfoRec",
+    "xf86InitCursor",
+    NULL
 };
 
 static const char *ddcSymbols[] =
 {
-	"xf86PrintEDID",
-	"xf86DoEDID_DDC1",
-	"xf86DoEDID_DDC2",
-	"xf86SetDDCproperties",
-	NULL
+    "xf86PrintEDID",
+    "xf86DoEDID_DDC1",
+    "xf86DoEDID_DDC2",
+    "xf86SetDDCproperties",
+    NULL
 };
 
 static const char *i2cSymbols[] =
 {
-	"xf86CreateI2CBusRec",
-	"xf86CreateI2CDevRec",
-	"xf86DestroyI2CBusRec",
-	"xf86DestroyI2CDevRec",
-	"xf86I2CBusInit",
-	"xf86I2CDevInit",
-	"xf86I2CReadBytes",
-	"xf86I2CWriteByte",
-	NULL
+    "xf86CreateI2CBusRec",
+    "xf86CreateI2CDevRec",
+    "xf86DestroyI2CBusRec",
+    "xf86DestroyI2CDevRec",
+    "xf86I2CBusInit",
+    "xf86I2CDevInit",
+    "xf86I2CReadBytes",
+    "xf86I2CWriteByte",
+    NULL
 };
 
 static const char *shadowSymbols[] =
 {
-	"ShadowFBInit",
-	NULL
+    "ShadowFBInit",
+    NULL
 };
 
 static const char *int10Symbols[] =
 {
-	"xf86ExecX86int10",
-	"xf86FreeInt10",
-	"xf86InitInt10",
-	NULL
+    "xf86ExecX86int10",
+    "xf86FreeInt10",
+    "xf86InitInt10",
+    NULL
 };
 
 static const char *vbeSymbols[] =
 {
-	"VBEInit",
-	"vbeDoEDID",
-	"vbeFree",
-	NULL
+    "VBEInit",
+    "vbeDoEDID",
+    "vbeFree",
+    NULL
 };
 
 static const char *fbSymbols[] =
 {
-	"fbPictureInit",
-	"fbScreenInit",
-	NULL
+    "fbPictureInit",
+    "fbScreenInit",
+    NULL
 };
 
 #ifdef XFree86LOADER
@@ -298,18 +297,18 @@ static MODULESETUPPROTO(siliconmotionSetup);
 
 static XF86ModuleVersionInfo SMIVersRec =
 {
-	"siliconmotion",
-	MODULEVENDORSTRING,
-	MODINFOSTRING1,
-	MODINFOSTRING2,
-	XORG_VERSION_CURRENT,
-	SILICONMOTION_VERSION_MAJOR,
-	SILICONMOTION_VERSION_MINOR,
-	SILICONMOTION_PATCHLEVEL,
-	ABI_CLASS_VIDEODRV,
-	ABI_VIDEODRV_VERSION,
-	MOD_CLASS_VIDEODRV,
-	{0, 0, 0, 0}
+    "siliconmotion",
+    MODULEVENDORSTRING,
+    MODINFOSTRING1,
+    MODINFOSTRING2,
+    XORG_VERSION_CURRENT,
+    SILICONMOTION_VERSION_MAJOR,
+    SILICONMOTION_VERSION_MINOR,
+    SILICONMOTION_PATCHLEVEL,
+    ABI_CLASS_VIDEODRV,
+    ABI_VIDEODRV_VERSION,
+    MOD_CLASS_VIDEODRV,
+    {0, 0, 0, 0}
 };
 
 /*
@@ -319,48 +318,45 @@ static XF86ModuleVersionInfo SMIVersRec =
  */
 _X_EXPORT XF86ModuleData siliconmotionModuleData =
 {
-	&SMIVersRec,
-	siliconmotionSetup,
-	NULL
+    &SMIVersRec,
+    siliconmotionSetup,
+    NULL
 };
 
 static pointer
 siliconmotionSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 {
-	static Bool setupDone = FALSE;
+    static Bool setupDone = FALSE;
 
-	if (!setupDone)
-	{
-		setupDone = TRUE;
-		xf86AddDriver(&SILICONMOTION, module, 0);
-
-		/*
-		 * Modules that this driver always requires can be loaded here
-		 * by calling LoadSubModule().
-		 */
-
-		/*
-		 * Tell the loader about symbols from other modules that this module
-		 * might refer to.
-		 */
-		LoaderRefSymLists(vgahwSymbols, fbSymbols, xaaSymbols, ramdacSymbols,
-						  ddcSymbols, i2cSymbols, int10Symbols, vbeSymbols,
-						  shadowSymbols, NULL);
-
-		/*
-		 * The return value must be non-NULL on success even though there
-		 * is no TearDownProc.
-		 */
-		return (pointer) 1;
-	}
-	else
-	{
-		if (errmaj)
-		{
-			*errmaj = LDR_ONCEONLY;
-		}
-		return(NULL);
+    if (!setupDone) {
+	setupDone = TRUE;
+	xf86AddDriver(&SILICONMOTION, module, 0);
+
+	/*
+	 * Modules that this driver always requires can be loaded here
+	 * by calling LoadSubModule().
+	 */
+
+	/*
+	 * Tell the loader about symbols from other modules that this module
+	 * might refer to.
+	 */
+	LoaderRefSymLists(vgahwSymbols, fbSymbols, xaaSymbols, ramdacSymbols,
+					  ddcSymbols, i2cSymbols, int10Symbols, vbeSymbols,
+					  shadowSymbols, NULL);
+
+	/*
+	 * The return value must be non-NULL on success even though there
+	 * is no TearDownProc.
+	 */
+	return (pointer) 1;
+
+    } else {
+	if (errmaj) {
+	    *errmaj = LDR_ONCEONLY;
 	}
+	return NULL;
+    }
 }
 
 #endif /* XFree86LOADER */
@@ -368,873 +364,757 @@ siliconmotionSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 static Bool
 SMI_GetRec(ScrnInfoPtr pScrn)
 {
-	ENTER_PROC("SMI_GetRec");
-
-	/*
-	 * Allocate an 'Chip'Rec, and hook it into pScrn->driverPrivate.
-	 * pScrn->driverPrivate is initialised to NULL, so we can check if
-	 * the allocation has already been done.
-	 */
-	if (pScrn->driverPrivate == NULL)
-	{
-		pScrn->driverPrivate = xnfcalloc(sizeof(SMIRec), 1);
-	}
-
-	LEAVE_PROC("SMI_GetRec");
-	return(TRUE);
+    ENTER_PROC("SMI_GetRec");
+
+    /*
+     * Allocate an 'Chip'Rec, and hook it into pScrn->driverPrivate.
+     * pScrn->driverPrivate is initialised to NULL, so we can check if
+     * the allocation has already been done.
+     */
+    if (pScrn->driverPrivate == NULL) {
+	pScrn->driverPrivate = xnfcalloc(sizeof(SMIRec), 1);
+    }
+
+    LEAVE_PROC("SMI_GetRec");
+    return TRUE;
 }
 
 static void
 SMI_FreeRec(ScrnInfoPtr pScrn)
 {
-	ENTER_PROC("SMI_FreeRec");
+    ENTER_PROC("SMI_FreeRec");
 
-	if (pScrn->driverPrivate != NULL)
-	{
-		xfree(pScrn->driverPrivate);
-		pScrn->driverPrivate = NULL;
-	}
+    if (pScrn->driverPrivate != NULL) {
+	xfree(pScrn->driverPrivate);
+	pScrn->driverPrivate = NULL;
+    }
 
-	LEAVE_PROC("SMI_FreeRec");
+    LEAVE_PROC("SMI_FreeRec");
 }
 
 static const OptionInfoRec *
 SMI_AvailableOptions(int chipid, int busid)
 {
-	ENTER_PROC("SMI_AvailableOptions");
-	LEAVE_PROC("SMI_AvailableOptions");
-	return(SMIOptions);
+    ENTER_PROC("SMI_AvailableOptions");
+    LEAVE_PROC("SMI_AvailableOptions");
+    return SMIOptions;
 }
 
 static void
 SMI_Identify(int flags)
 {
-	ENTER_PROC("SMI_Identify");
+    ENTER_PROC("SMI_Identify");
 
-	xf86PrintChipsets(SILICONMOTION_NAME, "driver (version "
-			SILICONMOTION_VERSION_NAME ") for Silicon Motion Lynx chipsets",
-			SMIChipsets);
+    xf86PrintChipsets(SILICONMOTION_NAME, "driver (version "
+		SILICONMOTION_VERSION_NAME ") for Silicon Motion Lynx chipsets",
+		SMIChipsets);
 
-	LEAVE_PROC("SMI_Identify");
+    LEAVE_PROC("SMI_Identify");
 }
 
 static Bool
 SMI_Probe(DriverPtr drv, int flags)
 {
-	int i;
-	GDevPtr *devSections;
-	int *usedChips;
-	int numDevSections;
-	int numUsed;
-	Bool foundScreen = FALSE;
+    int i;
+    GDevPtr *devSections;
+    int *usedChips;
+    int numDevSections;
+    int numUsed;
+    Bool foundScreen = FALSE;
 
-	ENTER_PROC("SMI_Probe");
+    ENTER_PROC("SMI_Probe");
 
-	numDevSections = xf86MatchDevice(SILICONMOTION_DRIVER_NAME, &devSections);
-	if (numDevSections <= 0)
-	{
-		/* There's no matching device section in the config file, so quit now.
-		 */
-		LEAVE_PROC("SMI_Probe");
-		return(FALSE);
-	}
+    numDevSections = xf86MatchDevice(SILICONMOTION_DRIVER_NAME, &devSections);
 
-	if (xf86GetPciVideoInfo() == NULL)
-	{
-		LEAVE_PROC("SMI_Probe");
-		return(FALSE);
-	}
+    if (numDevSections <= 0) {
+	/* There's no matching device section in the config file, so quit now. */
+	LEAVE_PROC("SMI_Probe");
+	return FALSE;
+    }
 
-	numUsed = xf86MatchPciInstances(SILICONMOTION_NAME, PCI_SMI_VENDOR_ID,
-									SMIChipsets, SMIPciChipsets, devSections,
-									numDevSections, drv, &usedChips);
+    if (xf86GetPciVideoInfo() == NULL) {
+	LEAVE_PROC("SMI_Probe");
+	return FALSE;
+    }
 
-	/* Free it since we don't need that list after this */
-	xfree(devSections);
-	if (numUsed <= 0)
-	{
-		LEAVE_PROC("SMI_Probe");
-		return(FALSE);
-	}
-
-	if (flags & PROBE_DETECT)
-	{
-		foundScreen = TRUE;
-	}
-	else
-	{
-		for (i = 0; i < numUsed; i++)
-		{
-			/* Allocate a ScrnInfoRec and claim the slot */
-			ScrnInfoPtr pScrn = xf86AllocateScreen(drv, 0);
-
-			/* Fill in what we can of the ScrnInfoRec */
-			pScrn->driverVersion = SILICONMOTION_DRIVER_VERSION;
-			pScrn->driverName	 = SILICONMOTION_DRIVER_NAME;
-			pScrn->name			 = SILICONMOTION_NAME;
-			pScrn->Probe		 = SMI_Probe;
-			pScrn->PreInit		 = SMI_PreInit;
-			pScrn->ScreenInit	 = SMI_ScreenInit;
-			pScrn->SwitchMode	 = SMI_SwitchMode;
-			pScrn->AdjustFrame	 = SMI_AdjustFrame;
-			pScrn->EnterVT		 = SMI_EnterVT;
-			pScrn->LeaveVT		 = SMI_LeaveVT;
-			pScrn->FreeScreen	 = SMI_FreeScreen;
-			pScrn->ValidMode	 = SMI_ValidMode;
-			foundScreen			 = TRUE;
-
-			xf86ConfigActivePciEntity(pScrn, usedChips[i], SMIPciChipsets, NULL,
-									  NULL, NULL, NULL, NULL);
-		}
-	}
-	xfree(usedChips);
+    numUsed = xf86MatchPciInstances(SILICONMOTION_NAME, PCI_SMI_VENDOR_ID,
+				    SMIChipsets, SMIPciChipsets, devSections,
+				    numDevSections, drv, &usedChips);
 
+    /* Free it since we don't need that list after this */
+    xfree(devSections);
+    if (numUsed <= 0) {
 	LEAVE_PROC("SMI_Probe");
-	return(foundScreen);
+	return FALSE;
+    }
+
+    if (flags & PROBE_DETECT) {
+		foundScreen = TRUE;
+    } else {
+	for (i = 0; i < numUsed; i++) {
+	    /* Allocate a ScrnInfoRec and claim the slot */
+	    ScrnInfoPtr pScrn = xf86AllocateScreen(drv, 0);
+
+	    /* Fill in what we can of the ScrnInfoRec */
+	    pScrn->driverVersion = SILICONMOTION_DRIVER_VERSION;
+	    pScrn->driverName	 = SILICONMOTION_DRIVER_NAME;
+	    pScrn->name		 = SILICONMOTION_NAME;
+	    pScrn->Probe	 = SMI_Probe;
+	    pScrn->PreInit	 = SMI_PreInit;
+	    pScrn->ScreenInit	 = SMI_ScreenInit;
+	    pScrn->SwitchMode	 = SMI_SwitchMode;
+	    pScrn->AdjustFrame	 = SMI_AdjustFrame;
+	    pScrn->EnterVT	 = SMI_EnterVT;
+	    pScrn->LeaveVT	 = SMI_LeaveVT;
+	    pScrn->FreeScreen	 = SMI_FreeScreen;
+	    pScrn->ValidMode	 = SMI_ValidMode;
+	    foundScreen		 = TRUE;
+
+	    xf86ConfigActivePciEntity(pScrn, usedChips[i], SMIPciChipsets, NULL,
+				      NULL, NULL, NULL, NULL);
+	}
+    }
+    xfree(usedChips);
+
+    LEAVE_PROC("SMI_Probe");
+    return foundScreen;
 }
 
 static Bool
 SMI_PreInit(ScrnInfoPtr pScrn, int flags)
 {
-	EntityInfoPtr pEnt;
-	SMIPtr pSmi;
-	MessageType from;
-	int i;
-	double real;
-	ClockRangePtr clockRanges;
-	char *s;
-	unsigned char config, m, n, shift;
-	int mclk;
-	vgaHWPtr hwp;
-	int vgaCRIndex, vgaIOBase;
-	vbeInfoPtr pVbe = NULL;
+    EntityInfoPtr pEnt;
+    SMIPtr pSmi;
+    MessageType from;
+    int i;
+    double real;
+    ClockRangePtr clockRanges;
+    char *s;
+    unsigned char config, m, n, shift;
+    int mclk;
+    vgaHWPtr hwp;
+    int vgaCRIndex, vgaIOBase;
+    vbeInfoPtr pVbe = NULL;
 	
-	ENTER_PROC("SMI_PreInit");
-
-	if (flags & PROBE_DETECT)
-	{
-		SMI_ProbeDDC(pScrn, xf86GetEntityInfo(pScrn->entityList[0])->index);
-		LEAVE_PROC("SMI_PreInit");
-		return(TRUE);
-	}
-
-	/* Ignoring the Type list for now.  It might be needed when multiple cards
-	 * are supported.
-	 */
-	if (pScrn->numEntities > 1)
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
+    ENTER_PROC("SMI_PreInit");
 
-	/* The vgahw module should be loaded here when needed */
-	if (!xf86LoadSubModule(pScrn, "vgahw"))
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	xf86LoaderReqSymLists(vgahwSymbols, NULL);
-
-	/*
-	 * Allocate a vgaHWRec
-	 */
-	if (!vgaHWGetHWRec(pScrn))
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	/* Allocate the SMIRec driverPrivate */
-	if (!SMI_GetRec(pScrn))
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-	pSmi = SMIPTR(pScrn);
-
-	/* Set pScrn->monitor */
-	pScrn->monitor = pScrn->confScreen->monitor;
-
-	/*
-	 * The first thing we should figure out is the depth, bpp, etc.
-	 * We support only 24bpp layouts, so indicate that.
-	 */
-	if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support24bppFb))
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	/* Check that the returned depth is one we support */
-	switch (pScrn->depth)
-	{
-		case 8:
-		case 16:
-		case 24:
-			/* OK */
-			break;
-
-		default:
-			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-					"Given depth (%d) is not supported by this driver\n",
-					pScrn->depth);
-			LEAVE_PROC("SMI_PreInit");
-			return(FALSE);
-	}
-	xf86PrintDepthBpp(pScrn);
-
-	/*
-	 * This must happen after pScrn->display has been set because
-	 * xf86SetWeight references it.
-	 */
-	if (pScrn->depth > 8)
-	{
-		/* The defaults are OK for us */
-		rgb zeros = {0, 0, 0};
-
-		if (!xf86SetWeight(pScrn, zeros, zeros))
-		{
-			LEAVE_PROC("SMI_PreInit");
-			return(FALSE);
-		}
-	}
-
-	if (!xf86SetDefaultVisual(pScrn, -1))
-	{
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	/* We don't currently support DirectColor at > 8bpp */
-	if ((pScrn->depth > 8) && (pScrn->defaultVisual != TrueColor))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual (%s) "
-				"is not supported at depth %d\n",
-				xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	/* We use a programmable clock */
-	pScrn->progClock = TRUE;
-
-	/* Collect all of the relevant option flags (fill in pScrn->options) */
-	xf86CollectOptions(pScrn, NULL);
-
-	/* Set the bits per RGB for 8bpp mode */
-	if (pScrn->depth == 8)
-	{
-		pScrn->rgbBits = 6;
-	}
-
-	/* Process the options */
-	if (!(pSmi->Options = xalloc(sizeof(SMIOptions))))
-		return FALSE;
-	memcpy(pSmi->Options, SMIOptions, sizeof(SMIOptions));
-	xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pSmi->Options);
-
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_BURST, FALSE))
-	{
-		pSmi->pci_burst = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: pci_burst - PCI burst "
-				"read enabled\n");
-	}
-	else
-	{
-		pSmi->pci_burst = FALSE;
-	}
+    if (flags & PROBE_DETECT) {
+	SMI_ProbeDDC(pScrn, xf86GetEntityInfo(pScrn->entityList[0])->index);
+	LEAVE_PROC("SMI_PreInit");
+	return TRUE;
+    }
 
-	pSmi->NoPCIRetry = TRUE;
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_RETRY, FALSE))
-	{
-		if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_BURST, FALSE))
-		{
-			pSmi->NoPCIRetry = FALSE;
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: pci_retry\n");
-		}
-		else
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "\"pci_retry\" option "
-					"requires \"pci_burst\".\n");
-		}
-	}
+    /* Ignoring the Type list for now.  It might be needed when multiple cards
+     * are supported.
+     */
+    if (pScrn->numEntities > 1) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_CONSERV))
-	{
-		pSmi->fifo_conservative = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_conservative "
-				"set\n");
-	}
-	else
-	{
-		pSmi->fifo_conservative = FALSE;
-	}
+    /* The vgahw module should be loaded here when needed */
+    if (!xf86LoadSubModule(pScrn, "vgahw")) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_MODERATE))
-	{
-		pSmi->fifo_moderate = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_moderate set\n");
-	}
-	else
-	{
-		pSmi->fifo_moderate = FALSE;
-	}
+    xf86LoaderReqSymLists(vgahwSymbols, NULL);
 
-	if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_AGGRESSIVE))
-	{
-		pSmi->fifo_aggressive = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_aggressive set\n");
-	}
-	else
-	{
-		pSmi->fifo_aggressive = FALSE;
-	}
+    /*
+     * Allocate a vgaHWRec
+     */
+    if (!vgaHWGetHWRec(pScrn)) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_NOACCEL, FALSE))
-	{
-		pSmi->NoAccel = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: NoAccel - Acceleration "
-				"disabled\n");
-	}
-	else
-	{
-		pSmi->NoAccel = FALSE;
-	}
+    /* Allocate the SMIRec driverPrivate */
+    if (!SMI_GetRec(pScrn)) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
+    pSmi = SMIPTR(pScrn);
+
+    /* Set pScrn->monitor */
+    pScrn->monitor = pScrn->confScreen->monitor;
+
+    /*
+     * The first thing we should figure out is the depth, bpp, etc.
+     * We support only 24bpp layouts, so indicate that.
+     */
+    if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support24bppFb)) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
+
+    /* Check that the returned depth is one we support */
+    switch (pScrn->depth) {
+    case 8:
+    case 16:
+    case 24:
+	/* OK */
+	break;
+
+    default:
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		   "Given depth (%d) is not supported by this driver\n",
+		   pScrn->depth);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_SHOWCACHE, FALSE))
-	{
-		pSmi->ShowCache = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: show_cache set\n");
-	}
-	else
-	{
-		pSmi->ShowCache = FALSE;
-	}
+    xf86PrintDepthBpp(pScrn);
 
-	if (xf86GetOptValFreq(pSmi->Options, OPTION_MCLK, OPTUNITS_MHZ, &real))
-	{
-		pSmi->MCLK = (int)(real * 1000.0);
-		if (pSmi->MCLK <= 120000)
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: set_mclk set to "
-					"%1.3f MHz\n", pSmi->MCLK / 1000.0);
-		}
-		else
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Memory Clock value of "
-					"%1.3f MHz is larger than limit of 120 MHz\n",
-					pSmi->MCLK / 1000.0);
-			pSmi->MCLK = 0;
-		}
-	}
-	else
-	{
-		pSmi->MCLK = 0;
-	}
+    /*
+     * This must happen after pScrn->display has been set because
+     * xf86SetWeight references it.
+     */
+    if (pScrn->depth > 8) {
+	/* The defaults are OK for us */
+	rgb zeros = {0, 0, 0};
 
-	from = X_DEFAULT;
-	pSmi->hwcursor = TRUE;
-	if (xf86GetOptValBool(pSmi->Options, OPTION_HWCURSOR, &pSmi->hwcursor))
-	{
-		from = X_CONFIG;
+	if (!xf86SetWeight(pScrn, zeros, zeros)) {
+	    LEAVE_PROC("SMI_PreInit");
+	    return FALSE;
 	}
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_SWCURSOR, FALSE))
-	{
-		pSmi->hwcursor = FALSE;
-		from = X_CONFIG;
-	}
-	xf86DrvMsg(pScrn->scrnIndex, from, "Using %s Cursor\n",
-			pSmi->hwcursor ? "Hardware" : "Software");
+    }
 
-	if (xf86GetOptValBool(pSmi->Options, OPTION_SHADOW_FB, &pSmi->shadowFB))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShadowFB %s.\n",
-				pSmi->shadowFB ? "enabled" : "disabled");
-	}
+    if (!xf86SetDefaultVisual(pScrn, -1)) {
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
+
+    /* We don't currently support DirectColor at > 8bpp */
+    if ((pScrn->depth > 8) && (pScrn->defaultVisual != TrueColor)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual (%s) "
+		   "is not supported at depth %d\n",
+		   xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
+
+    /* We use a programmable clock */
+    pScrn->progClock = TRUE;
+
+    /* Collect all of the relevant option flags (fill in pScrn->options) */
+    xf86CollectOptions(pScrn, NULL);
+
+    /* Set the bits per RGB for 8bpp mode */
+    if (pScrn->depth == 8) {
+	pScrn->rgbBits = 6;
+    }
+
+    /* Process the options */
+    if (!(pSmi->Options = xalloc(sizeof(SMIOptions))))
+	return FALSE;
+    memcpy(pSmi->Options, SMIOptions, sizeof(SMIOptions));
+    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pSmi->Options);
+
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_BURST, FALSE)) {
+	pSmi->pci_burst = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: pci_burst - PCI burst "
+		   "read enabled\n");
+    } else {
+	pSmi->pci_burst = FALSE;
+    }
+
+    pSmi->NoPCIRetry = TRUE;
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_RETRY, FALSE)) {
+	if (xf86ReturnOptValBool(pSmi->Options, OPTION_PCI_BURST, FALSE)) {
+	    pSmi->NoPCIRetry = FALSE;
+	    xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: pci_retry\n");
+	} else {
+	    xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "\"pci_retry\" option "
+		       "requires \"pci_burst\".\n");
+	}
+    }
+
+    if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_CONSERV)) {
+	pSmi->fifo_conservative = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_conservative "
+		   "set\n");
+    } else {
+	pSmi->fifo_conservative = FALSE;
+    }
+
+    if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_MODERATE)) {
+	pSmi->fifo_moderate = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_moderate set\n");
+    } else {
+	pSmi->fifo_moderate = FALSE;
+    }
+
+    if (xf86IsOptionSet(pSmi->Options, OPTION_FIFO_AGGRESSIVE)) {
+	pSmi->fifo_aggressive = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: fifo_aggressive set\n");
+    } else {
+	pSmi->fifo_aggressive = FALSE;
+    }
+
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_NOACCEL, FALSE)) {
+	pSmi->NoAccel = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: NoAccel - Acceleration "
+		   "disabled\n");
+    } else {
+	pSmi->NoAccel = FALSE;
+    }
+
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_SHOWCACHE, FALSE)) {
+	pSmi->ShowCache = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: show_cache set\n");
+    } else {
+	pSmi->ShowCache = FALSE;
+    }
+
+    if (xf86GetOptValFreq(pSmi->Options, OPTION_MCLK, OPTUNITS_MHZ, &real)) {
+	pSmi->MCLK = (int)(real * 1000.0);
+	if (pSmi->MCLK <= 120000) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: set_mclk set to "
+		       "%1.3f MHz\n", pSmi->MCLK / 1000.0);
+	} else {
+	    xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Memory Clock value of "
+		       "%1.3f MHz is larger than limit of 120 MHz\n",
+		       pSmi->MCLK / 1000.0);
+	    pSmi->MCLK = 0;
+	}
+    } else {
+	pSmi->MCLK = 0;
+    }
+
+    from = X_DEFAULT;
+    pSmi->hwcursor = TRUE;
+    if (xf86GetOptValBool(pSmi->Options, OPTION_HWCURSOR, &pSmi->hwcursor)) {
+	from = X_CONFIG;
+    }
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_SWCURSOR, FALSE)) {
+	pSmi->hwcursor = FALSE;
+	from = X_CONFIG;
+    }
+    xf86DrvMsg(pScrn->scrnIndex, from, "Using %s Cursor\n",
+	       pSmi->hwcursor ? "Hardware" : "Software");
+
+    if (xf86GetOptValBool(pSmi->Options, OPTION_SHADOW_FB, &pSmi->shadowFB)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShadowFB %s.\n",
+		   pSmi->shadowFB ? "enabled" : "disabled");
+    }
 
 #if 1 /* PDR#932 */
-	if ((pScrn->depth == 8) || (pScrn->depth == 16))
+    if ((pScrn->depth == 8) || (pScrn->depth == 16))
 #endif /* PDR#932 */
-	if ((s = xf86GetOptValString(pSmi->Options, OPTION_ROTATE)))
-	{
-		if(!xf86NameCmp(s, "CW"))
-		{
-			pSmi->shadowFB = TRUE;
-			pSmi->rotate = SMI_ROTATE_CCW;
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rotating screen "
-					"clockwise\n");
-		}
-		else if (!xf86NameCmp(s, "CCW"))
-		{
-			pSmi->shadowFB = TRUE;
-			pSmi->rotate = SMI_ROTATE_CW;
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rotating screen counter "
-					"clockwise\n");
-		}
-		else
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "\"%s\" is not a valid "
-					"value for Option \"Rotate\"\n", s);
-			xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Valid options are \"CW\" or "
-					"\"CCW\"\n");
-		}
+	if ((s = xf86GetOptValString(pSmi->Options, OPTION_ROTATE))) {
+	    if (!xf86NameCmp(s, "CW")) {
+		pSmi->shadowFB = TRUE;
+		pSmi->rotate = SMI_ROTATE_CCW;
+		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rotating screen "
+			   "clockwise\n");
+	    } else if (!xf86NameCmp(s, "CCW")) {
+		pSmi->shadowFB = TRUE;
+		pSmi->rotate = SMI_ROTATE_CW;
+		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Rotating screen counter "
+			   "clockwise\n");
+	    } else {
+		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "\"%s\" is not a valid "
+			   "value for Option \"Rotate\"\n", s);
+		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Valid options are \"CW\" or "
+			   "\"CCW\"\n");
+	    }
 	}
 
-	if (pSmi->rotate)
-	{
-		/* Disable the RandR extension, it messes up the internal rotation stuff */
-		xf86DisableRandR();
-	}
+    if (pSmi->rotate) {
+	/* Disable the RandR extension, it messes up the internal rotation stuff */
+	xf86DisableRandR();
+    }
 		
-	if (xf86GetOptValInteger(pSmi->Options, OPTION_VIDEOKEY, &pSmi->videoKey))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: Video key set to "
-				"0x%08X\n", pSmi->videoKey);
-	}
-	else
-	{
-		pSmi->videoKey = (1 << pScrn->offset.red) | (1 << pScrn->offset.green)
-				| (((pScrn->mask.blue >> pScrn->offset.blue) - 1)
-						<< pScrn->offset.blue);
-	}
+    if (xf86GetOptValInteger(pSmi->Options, OPTION_VIDEOKEY, &pSmi->videoKey)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: Video key set to "
+		   "0x%08X\n", pSmi->videoKey);
+    } else {
+	pSmi->videoKey = (1 << pScrn->offset.red) |
+			 (1 << pScrn->offset.green) |
+			 (((pScrn->mask.blue >> pScrn->offset.blue) - 1)
+			 << pScrn->offset.blue);
+    }
+
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_BYTESWAP, FALSE)) {
+	pSmi->ByteSwap = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: ByteSwap enabled.\n");
+    } else {
+	pSmi->ByteSwap = FALSE;
+    }
 
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_BYTESWAP, FALSE))
-	{
-		pSmi->ByteSwap = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: ByteSwap enabled.\n");
-	}
-	else
-	{
-		pSmi->ByteSwap = FALSE;
-	}
-
-	/* CZ 26.10.2001: interlaced video */
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_INTERLACED, FALSE))
-	{
-		pSmi->interlaced = TRUE;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: Interlaced enabled.\n");
-	}
-	else
-	{
-		pSmi->interlaced = FALSE;
-	}
-	/* end CZ */
-
-	if (xf86GetOptValBool(pSmi->Options, OPTION_USEBIOS, &pSmi->useBIOS))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: UseBIOS %s.\n",
-				pSmi->useBIOS ? "enabled" : "disabled");
-	}
-	else
-	{
-		/* Default to UseBIOS enabled. */
-		pSmi->useBIOS = TRUE;
-	}
-
-	if (xf86GetOptValBool(pSmi->Options, OPTION_ZOOMONLCD, &pSmi->zoomOnLCD))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: ZoomOnLCD %s.\n",
-				pSmi->zoomOnLCD ? "enabled" : "disabled");
-	}
-	else
-	{
-		/* Default to ZoomOnLCD enabled. */
-		pSmi->zoomOnLCD = TRUE;
-	}
-
-	/* Find the PCI slot for this screen */
-	pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
-	if ((pEnt->location.type != BUS_PCI) || (pEnt->resources))
-	{
-		xfree(pEnt);
-		SMI_FreeRec(pScrn);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
+    /* CZ 26.10.2001: interlaced video */
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_INTERLACED, FALSE)) {
+	pSmi->interlaced = TRUE;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: Interlaced enabled.\n");
+    } else {
+	pSmi->interlaced = FALSE;
+    }
+    /* end CZ */
+
+    if (xf86GetOptValBool(pSmi->Options, OPTION_USEBIOS, &pSmi->useBIOS)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: UseBIOS %s.\n",
+		   pSmi->useBIOS ? "enabled" : "disabled");
+    } else {
+	/* Default to UseBIOS enabled. */
+	pSmi->useBIOS = TRUE;
+    }
+
+    if (xf86GetOptValBool(pSmi->Options, OPTION_ZOOMONLCD, &pSmi->zoomOnLCD)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: ZoomOnLCD %s.\n",
+		   pSmi->zoomOnLCD ? "enabled" : "disabled");
+    } else {
+	/* Default to ZoomOnLCD enabled. */
+	pSmi->zoomOnLCD = TRUE;
+    }
+
+    /* Find the PCI slot for this screen */
+    pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+    if ((pEnt->location.type != BUS_PCI) || (pEnt->resources)) {
+	xfree(pEnt);
+	SMI_FreeRec(pScrn);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (xf86LoadSubModule(pScrn,"int10")) {
-	    xf86LoaderReqSymLists(int10Symbols,NULL);
-	    pSmi->pInt10 = xf86InitInt10(pEnt->index);
-	}
+    if (xf86LoadSubModule(pScrn,"int10")) {
+	xf86LoaderReqSymLists(int10Symbols,NULL);
+	pSmi->pInt10 = xf86InitInt10(pEnt->index);
+    }
 	
-	if (pSmi->pInt10 && xf86LoadSubModule(pScrn, "vbe"))
-	{
-	    xf86LoaderReqSymLists(vbeSymbols, NULL);
-	    pVbe = VBEInit(pSmi->pInt10, pEnt->index);
-	}
-
-	pSmi->PciInfo = xf86GetPciInfoForEntity(pEnt->index);
-	xf86RegisterResources(pEnt->index, NULL, ResExclusive);
-/*	xf86SetOperatingState(resVgaIo, pEnt->index, ResUnusedOpr); */
-/*	xf86SetOperatingState(resVgaMem, pEnt->index, ResDisableOpr); */
-
-	/*
-	 * Set the Chipset and ChipRev, allowing config file entries to
-	 * override.
-	 */
-	if (pEnt->device->chipset && *pEnt->device->chipset)
-	{
-		pScrn->chipset = pEnt->device->chipset;
-		pSmi->Chipset = xf86StringToToken(SMIChipsets, pScrn->chipset);
-		from = X_CONFIG;
-	}
-	else if (pEnt->device->chipID >= 0)
-	{
-		pSmi->Chipset = pEnt->device->chipID;
-		pScrn->chipset = (char *) xf86TokenToString(SMIChipsets, pSmi->Chipset);
-		from = X_CONFIG;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
-				pSmi->Chipset);
-	}
-	else
-	{
-		from = X_PROBED;
-		pSmi->Chipset = pSmi->PciInfo->chipType;
-		pScrn->chipset = (char *) xf86TokenToString(SMIChipsets, pSmi->Chipset);
-	}
+    if (pSmi->pInt10 && xf86LoadSubModule(pScrn, "vbe")) {
+	xf86LoaderReqSymLists(vbeSymbols, NULL);
+	pVbe = VBEInit(pSmi->pInt10, pEnt->index);
+    }
+
+    pSmi->PciInfo = xf86GetPciInfoForEntity(pEnt->index);
+    xf86RegisterResources(pEnt->index, NULL, ResExclusive);
+/*  xf86SetOperatingState(resVgaIo, pEnt->index, ResUnusedOpr); */
+/*  xf86SetOperatingState(resVgaMem, pEnt->index, ResDisableOpr); */
+
+    /*
+     * Set the Chipset and ChipRev, allowing config file entries to
+     * override.
+     */
+    if (pEnt->device->chipset && *pEnt->device->chipset) {
+	pScrn->chipset = pEnt->device->chipset;
+	pSmi->Chipset = xf86StringToToken(SMIChipsets, pScrn->chipset);
+	from = X_CONFIG;
+    } else if (pEnt->device->chipID >= 0) {
+	pSmi->Chipset = pEnt->device->chipID;
+	pScrn->chipset = (char *) xf86TokenToString(SMIChipsets, pSmi->Chipset);
+	from = X_CONFIG;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
+		   pSmi->Chipset);
+    } else {
+	from = X_PROBED;
+	pSmi->Chipset = pSmi->PciInfo->chipType;
+	pScrn->chipset = (char *) xf86TokenToString(SMIChipsets, pSmi->Chipset);
+    }
+
+    if (pEnt->device->chipRev >= 0) {
+	pSmi->ChipRev = pEnt->device->chipRev;
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
+		   pSmi->ChipRev);
+    } else {
+	pSmi->ChipRev = pSmi->PciInfo->chipRev;
+    }
+    xfree(pEnt);
+
+    /*
+     * This shouldn't happen because such problems should be caught in
+     * SMI_Probe(), but check it just in case.
+     */
+    if (pScrn->chipset == NULL) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "ChipID 0x%04X is not "
+				"recognised\n", pSmi->Chipset);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	if (pEnt->device->chipRev >= 0)
-	{
-		pSmi->ChipRev = pEnt->device->chipRev;
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
-				pSmi->ChipRev);
-	}
-	else
-	{
-		pSmi->ChipRev = pSmi->PciInfo->chipRev;
-	}
-	xfree(pEnt);
+    if (pSmi->Chipset < 0) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Chipset \"%s\" is not "
+		   "recognised\n", pScrn->chipset);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	/*
-	 * This shouldn't happen because such problems should be caught in
-	 * SMI_Probe(), but check it just in case.
-	 */
-	if (pScrn->chipset == NULL)
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "ChipID 0x%04X is not "
-				"recognised\n", pSmi->Chipset);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-	if (pSmi->Chipset < 0)
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Chipset \"%s\" is not "
-				"recognised\n", pScrn->chipset);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
+    xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n", pScrn->chipset);
 
-	xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n", pScrn->chipset);
+    pSmi->PciTag = pciTag(pSmi->PciInfo->bus, pSmi->PciInfo->device,
+		   	  pSmi->PciInfo->func);
 
-	pSmi->PciTag = pciTag(pSmi->PciInfo->bus, pSmi->PciInfo->device,
-			pSmi->PciInfo->func);
+    pSmi->Dualhead = FALSE;
+    if (xf86ReturnOptValBool(pSmi->Options, OPTION_DUALHEAD, FALSE) &&
+	SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	pSmi->Dualhead = TRUE;
+    }
 
-	pSmi->Dualhead = FALSE;
-	if (xf86ReturnOptValBool(pSmi->Options, OPTION_DUALHEAD, FALSE) &&
-	    SMI_LYNXM_SERIES(pSmi->Chipset))
-	{
-	    pSmi->Dualhead = TRUE;
+    /* tweak options for dualhead */
+    if (pSmi->Dualhead) {
+	pSmi->useBIOS = FALSE;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "UseBIOS disabled in dualhead mode\n");
+	pSmi->hwcursor = FALSE;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No hardware cursor in dualhead mode\n");
+	if (pScrn->bitsPerPixel != 16) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Dualhead only supported at "
+		       "depth 16\n");
+	    return FALSE;
 	}
+    }
 
-	/* tweak options for dualhead */
-	if (pSmi->Dualhead) {
-	    pSmi->useBIOS = FALSE;
-	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "UseBIOS disabled in dualhead mode\n");
-	    pSmi->hwcursor = FALSE;
-	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No hardware cursor in dualhead mode\n");
-	    if (pScrn->bitsPerPixel != 16) {
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Dualhead only supported at "
-				"depth 16\n");
-		return FALSE;
-	    }
-	}
+    SMI_MapMem(pScrn);
+    SMI_DisableVideo(pScrn);
 
-	SMI_MapMem(pScrn);
-	SMI_DisableVideo(pScrn);
+    hwp = VGAHWPTR(pScrn);
+    vgaIOBase  = hwp->IOBase;
+    vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
+    pSmi->PIOBase = hwp->PIOOffset;
 
-	hwp = VGAHWPTR(pScrn);
-	vgaIOBase  = hwp->IOBase;
-	vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
-	pSmi->PIOBase = hwp->PIOOffset;
+    xf86ErrorFVerb(VERBLEV, "\tSMI_PreInit vgaCRIndex=%x, vgaIOBase=%x, "
+		   "MMIOBase=%p\n", vgaCRIndex, vgaIOBase, hwp->MMIOBase);
 
-	xf86ErrorFVerb(VERBLEV, "\tSMI_PreInit vgaCRIndex=%x, vgaIOBase=%x, "
-			"MMIOBase=%p\n", vgaCRIndex, vgaIOBase, hwp->MMIOBase);
+    /* detect the panel size */
+    SMI_DetectPanelSize(pScrn);
 
-	/* detect the panel size */
-	SMI_DetectPanelSize(pScrn);
+    if (xf86LoadSubModule(pScrn, "i2c")) {
+	xf86LoaderReqSymLists(i2cSymbols, NULL);
+	SMI_I2CInit(pScrn);
+    }
 
-	if (xf86LoadSubModule(pScrn, "i2c"))
-	{
-		xf86LoaderReqSymLists(i2cSymbols, NULL);
-		SMI_I2CInit(pScrn);
-	}
-	if (xf86LoadSubModule(pScrn, "ddc"))
-	{
-		xf86MonPtr pMon = NULL;
+    if (xf86LoadSubModule(pScrn, "ddc")) {
+	xf86MonPtr pMon = NULL;
 
-		xf86LoaderReqSymLists(ddcSymbols, NULL);
+	xf86LoaderReqSymLists(ddcSymbols, NULL);
 #if 1 /* PDR#579 */
-		if (pVbe)
-		{
-			pMon = vbeDoEDID(pVbe, NULL);
-			if (pMon != NULL)
-			{
-				if (   (pMon->rawData[0] == 0x00)
-					&& (pMon->rawData[1] == 0xFF)
-					&& (pMon->rawData[2] == 0xFF)
-					&& (pMon->rawData[3] == 0xFF)
-					&& (pMon->rawData[4] == 0xFF)
-					&& (pMon->rawData[5] == 0xFF)
-					&& (pMon->rawData[6] == 0xFF)
-					&& (pMon->rawData[7] == 0x00)
-				)
-				{
-					pMon = xf86PrintEDID(pMon);
-					if (pMon != NULL)
-					{
-						xf86SetDDCproperties(pScrn, pMon);
-					}
-				}
-			}
-		}
-#else
-		if (   (pVbe)
-			&& ((pMon = xf86PrintEDID(vbeDoEDID(pVbe, NULL))) != NULL)
-		)
-		{
+	if (pVbe) {
+	    pMon = vbeDoEDID(pVbe, NULL);
+	    if (pMon != NULL) {
+		if ((pMon->rawData[0] == 0x00) &&
+		    (pMon->rawData[1] == 0xFF) &&
+		    (pMon->rawData[2] == 0xFF) &&
+		    (pMon->rawData[3] == 0xFF) &&
+		    (pMon->rawData[4] == 0xFF) &&
+		    (pMon->rawData[5] == 0xFF) &&
+		    (pMon->rawData[6] == 0xFF) &&
+		    (pMon->rawData[7] == 0x00)) {
+		    pMon = xf86PrintEDID(pMon);
+		    if (pMon != NULL) {
 			xf86SetDDCproperties(pScrn, pMon);
+		    }
 		}
+	    }
+#else
+	if ((pVbe) && 
+	    ((pMon = xf86PrintEDID(vbeDoEDID(pVbe, NULL))) != NULL)) {
+	    xf86SetDDCproperties(pScrn, pMon);
 #endif
-		else if (!SMI_ddc1(pScrn->scrnIndex))
-		{
-			if (pSmi->I2C)
-			{
-				xf86SetDDCproperties(pScrn,
-						xf86PrintEDID(xf86DoEDID_DDC2(pScrn->scrnIndex,
-								pSmi->I2C)));
-			}
-		}
-	}
-
-	vbeFree(pVbe);
-	xf86FreeInt10(pSmi->pInt10);
-	pSmi->pInt10 = NULL;
-
-	/*
-	 * If the driver can do gamma correction, it should call xf86SetGamma()
-	 * here. (from MGA, no ViRGE gamma support yet, but needed for
-	 * xf86HandleColormaps support.)
-	 */
-	{
-		Gamma zeros = { 0.0, 0.0, 0.0 };
-
-		if (!xf86SetGamma(pScrn, zeros))
-		{
-			LEAVE_PROC("SMI_PreInit");
-			SMI_EnableVideo(pScrn);
-			SMI_UnmapMem(pScrn);
-			return(FALSE);
-		}
-	}
-
-
-	/* Next go on to detect amount of installed ram */
-	config = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x71);
-
-	/* And compute the amount of video memory and offscreen memory */
-	pSmi->videoRAMKBytes = 0;
-
-	if (!pScrn->videoRam)
-	{
-		switch (pSmi->Chipset)
-		{
-			default:
-			{
-				int mem_table[4] = { 1, 2, 4, 0 };
-				pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024;
-				break;
-			}
-
-			case SMI_LYNX3D:
-			{
-				int mem_table[4] = { 0, 2, 4, 6 };
-				pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024 + 512;
-				break;
-			}
-
-			case SMI_LYNX3DM:
-			{
-				int mem_table[4] = { 16, 2, 4, 8 };
-				pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024;
-				break;
-			}
-
-			case SMI_COUGAR3DR:
-			{
-				/* DANGER - Cougar3DR BIOS is broken - hardcode video ram size */
-				/* per instructions from Silicon Motion engineers */
-				pSmi->videoRAMKBytes = 16 * 1024;
-				break;
-            }
-		}
-		pSmi->videoRAMBytes = pSmi->videoRAMKBytes * 1024;
-		pScrn->videoRam     = pSmi->videoRAMKBytes;
-
-		xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "videoram: %dkB\n",
-				pSmi->videoRAMKBytes);
-	}
-	else
-	{
-		pSmi->videoRAMKBytes = pScrn->videoRam;
-		pSmi->videoRAMBytes  = pScrn->videoRam * 1024;
-
-		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "videoram: %dk\n",
-				pSmi->videoRAMKBytes);
-	}
+    	} else if (!SMI_ddc1(pScrn->scrnIndex)) {
+	    if (pSmi->I2C) {
+	    	xf86SetDDCproperties(pScrn,
+			xf86PrintEDID(xf86DoEDID_DDC2(pScrn->scrnIndex,
+			pSmi->I2C)));
+	    }
+    	}
+    }
 
-	/* Detect current MCLK and print it for user */
-	m = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A);
-	n = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B);
-	switch (n >> 6)
-	{
-		default:
-			shift = 1;
-			break;
+    vbeFree(pVbe);
+    xf86FreeInt10(pSmi->pInt10);
+    pSmi->pInt10 = NULL;
 
-		case 1:
-			shift = 4;
-			break;
+    /*
+     * If the driver can do gamma correction, it should call xf86SetGamma()
+     * here. (from MGA, no ViRGE gamma support yet, but needed for
+     * xf86HandleColormaps support.)
+     */
+    {
+	Gamma zeros = { 0.0, 0.0, 0.0 };
 
-		case 2:
-			shift = 2;
-			break;
+	if (!xf86SetGamma(pScrn, zeros)) {
+	    LEAVE_PROC("SMI_PreInit");
+	    SMI_EnableVideo(pScrn);
+	    SMI_UnmapMem(pScrn);
+	    return FALSE;
 	}
-	n &= 0x3F;
-	mclk = ((1431818 * m) / n / shift + 50) / 100;
-	xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Detected current MCLK value of "
-			"%1.3f MHz\n", mclk / 1000.0);
+    }
 
-	SMI_EnableVideo(pScrn);
-	SMI_UnmapMem(pScrn);
-
-	pSmi->IsSwitching = FALSE;
 
-	if (pSmi->Dualhead) {
-	    pScrn->display->virtualX = 2 * pSmi->lcdWidth;
-	    pScrn->display->virtualY = pSmi->lcdHeight;
-	}
+    /* Next go on to detect amount of installed ram */
+    config = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x71);
 
-	pScrn->virtualX = pScrn->display->virtualX;
+    /* And compute the amount of video memory and offscreen memory */
+    pSmi->videoRAMKBytes = 0;
 
-	/*
-	 * Setup the ClockRanges, which describe what clock ranges are available,
-	 * and what sort of modes they can be used for.
-	 */
-	clockRanges = xnfcalloc(sizeof(ClockRange),1);
-	clockRanges->next = NULL;
-	clockRanges->minClock = 20000;
-
-        if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR))
-            clockRanges->maxClock = 200000;
-        else
-            clockRanges->maxClock = 135000;
-
-	clockRanges->clockIndex = -1;
-	clockRanges->interlaceAllowed = FALSE;
-	clockRanges->doubleScanAllowed = FALSE;
-		
-	i = xf86ValidateModes(
-			pScrn,						/* Screen pointer					  */
-			pScrn->monitor->Modes,		/* Available monitor modes			  */
-			pScrn->display->modes,		/* req mode names for screen		  */
-			clockRanges,				/* list of clock ranges allowed		  */
-			NULL,						/* use min/max below				  */
-			128,						/* min line pitch (width)			  */
-			4096,						/* maximum line pitch (width)		  */
-			128,						/* bits of granularity for line pitch */
-										/* (width) above					  */
-			128,						/* min virtual height				  */
-			4096,						/* max virtual height				  */
-			pScrn->display->virtualX,	/* force virtual x					  */
-			pScrn->display->virtualY,	/* force virtual Y					  */
-			pSmi->videoRAMBytes,		/* size of aperture used to access	  */
-										/* video memory						  */
-			LOOKUP_BEST_REFRESH);		/* how to pick modes				  */
-
-	if (i == -1)
-	{
-		SMI_FreeRec(pScrn);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-
-	/* Prune the modes marked as invalid */
-	xf86PruneDriverModes(pScrn);
-
-	if ((i == 0) || (pScrn->modes == NULL))
+    if (!pScrn->videoRam) {
+	switch (pSmi->Chipset) {
+	default:
 	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
-		SMI_FreeRec(pScrn);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
-	xf86SetCrtcForModes(pScrn, 0);
-
-	/* Set the current mode to the first in the list */
-	pScrn->currentMode = pScrn->modes;
-
-	/* Print the list of modes being used */
-	xf86PrintModes(pScrn);
+	    int mem_table[4] = { 1, 2, 4, 0 };
+	    pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024;
+	    break;
+	}
+	case SMI_LYNX3D:
+	{
+	    int mem_table[4] = { 0, 2, 4, 6 };
+	    pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024 + 512;
+	    break;
+	}
+	case SMI_LYNX3DM:
+	{
+	    int mem_table[4] = { 16, 2, 4, 8 };
+	    pSmi->videoRAMKBytes = mem_table[(config >> 6)] * 1024;
+	    break;
+	}
+	case SMI_COUGAR3DR:
+	{
+	    /* DANGER - Cougar3DR BIOS is broken - hardcode video ram size */
+	    /* per instructions from Silicon Motion engineers */
+	    pSmi->videoRAMKBytes = 16 * 1024;
+	    break;
+        }
+	}
+	pSmi->videoRAMBytes = pSmi->videoRAMKBytes * 1024;
+	pScrn->videoRam     = pSmi->videoRAMKBytes;
+
+	xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "videoram: %dkB\n",
+		   pSmi->videoRAMKBytes);
+    } else {
+	pSmi->videoRAMKBytes = pScrn->videoRam;
+	pSmi->videoRAMBytes  = pScrn->videoRam * 1024;
+
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "videoram: %dk\n",
+		   pSmi->videoRAMKBytes);
+    }
+
+    /* Detect current MCLK and print it for user */
+    m = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A);
+    n = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B);
+    switch (n >> 6) {
+    default:
+	shift = 1;
+	break;
+    case 1:
+	shift = 4;
+	break;
+    case 2:
+	shift = 2;
+	break;
+    }
+    n &= 0x3F;
+    mclk = ((1431818 * m) / n / shift + 50) / 100;
+    xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Detected current MCLK value of "
+	       "%1.3f MHz\n", mclk / 1000.0);
+
+    SMI_EnableVideo(pScrn);
+    SMI_UnmapMem(pScrn);
+
+    pSmi->IsSwitching = FALSE;
+
+    if (pSmi->Dualhead) {
+	pScrn->display->virtualX = 2 * pSmi->lcdWidth;
+	pScrn->display->virtualY = pSmi->lcdHeight;
+    }
+
+    pScrn->virtualX = pScrn->display->virtualX;
+
+    /*
+     * Setup the ClockRanges, which describe what clock ranges are available,
+     * and what sort of modes they can be used for.
+     */
+    clockRanges = xnfcalloc(sizeof(ClockRange),1);
+    clockRanges->next = NULL;
+    clockRanges->minClock = 20000;
+
+    if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR))
+	clockRanges->maxClock = 200000;
+    else
+        clockRanges->maxClock = 135000;
+
+    clockRanges->clockIndex = -1;
+    clockRanges->interlaceAllowed = FALSE;
+    clockRanges->doubleScanAllowed = FALSE;
+		
+    i = xf86ValidateModes(
+		pScrn,				/* Screen pointer			  */
+		pScrn->monitor->Modes,		/* Available monitor modes		  */
+		pScrn->display->modes,		/* req mode names for screen		  */
+		clockRanges,			/* list of clock ranges allowed		  */
+		NULL,				/* use min/max below			  */
+		128,				/* min line pitch (width)		  */
+		4096,				/* maximum line pitch (width)		  */
+		128,				/* bits of granularity for line pitch     */
+						/* (width) above			  */
+		128,				/* min virtual height			  */
+		4096,				/* max virtual height			  */
+		pScrn->display->virtualX,	/* force virtual x			  */
+		pScrn->display->virtualY,	/* force virtual Y			  */
+		pSmi->videoRAMBytes,		/* size of aperture used to access	  */
+						/* video memory				  */
+		LOOKUP_BEST_REFRESH);		/* how to pick modes			  */
+
+    if (i == -1) {
+	SMI_FreeRec(pScrn);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
 
-	/* Set display resolution */
-	xf86SetDpi(pScrn, 0, 0);
+    /* Prune the modes marked as invalid */
+    xf86PruneDriverModes(pScrn);
 
-	if ((xf86LoadSubModule(pScrn, "fb") == NULL))
-	{
-		SMI_FreeRec(pScrn);
-		LEAVE_PROC("SMI_PreInit");
-		return(FALSE);
-	}
+    if ((i == 0) || (pScrn->modes == NULL)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
+	SMI_FreeRec(pScrn);
+	LEAVE_PROC("SMI_PreInit");
+	return FALSE;
+    }
+    xf86SetCrtcForModes(pScrn, 0);
 
-	xf86LoaderReqSymLists(fbSymbols, NULL);
-	/* Load XAA if needed */
-	if (!pSmi->NoAccel || pSmi->hwcursor)
-	{
-		if (!xf86LoadSubModule(pScrn, "xaa"))
-		{
-			SMI_FreeRec(pScrn);
-			LEAVE_PROC("SMI_PreInit");
-			return(FALSE);
-		}
-		xf86LoaderReqSymLists(xaaSymbols, NULL);
-	}
+    /* Set the current mode to the first in the list */
+    pScrn->currentMode = pScrn->modes;
 
-	/* Load ramdac if needed */
-	if (pSmi->hwcursor)
-	{
-		if (!xf86LoadSubModule(pScrn, "ramdac"))
-		{
-			SMI_FreeRec(pScrn);
-			LEAVE_PROC("SMI_PreInit");
-			return(FALSE);
-		}
-		xf86LoaderReqSymLists(ramdacSymbols, NULL);
-	}
+    /* Print the list of modes being used */
+    xf86PrintModes(pScrn);
 
-	if (pSmi->shadowFB)
-	{
-		if (!xf86LoadSubModule(pScrn, "shadowfb"))
-		{
-			SMI_FreeRec(pScrn);
-			LEAVE_PROC("SMI_PreInit");
-			return(FALSE);
-		}
-		xf86LoaderReqSymLists(shadowSymbols, NULL);
-	}
+    /* Set display resolution */
+    xf86SetDpi(pScrn, 0, 0);
 
+    if ((xf86LoadSubModule(pScrn, "fb") == NULL)) {
+	SMI_FreeRec(pScrn);
 	LEAVE_PROC("SMI_PreInit");
-	return(TRUE);
+	return FALSE;
+    }
+
+    xf86LoaderReqSymLists(fbSymbols, NULL);
+    /* Load XAA if needed */
+    if (!pSmi->NoAccel || pSmi->hwcursor) {
+	if (!xf86LoadSubModule(pScrn, "xaa")) {
+	    SMI_FreeRec(pScrn);
+	    LEAVE_PROC("SMI_PreInit");
+	    return FALSE;
+	}
+	xf86LoaderReqSymLists(xaaSymbols, NULL);
+    }
+
+    /* Load ramdac if needed */
+    if (pSmi->hwcursor) {
+	if (!xf86LoadSubModule(pScrn, "ramdac")) {
+	    SMI_FreeRec(pScrn);
+	    LEAVE_PROC("SMI_PreInit");
+	    return FALSE;
+	}
+	xf86LoaderReqSymLists(ramdacSymbols, NULL);
+    }
+
+    if (pSmi->shadowFB) {
+	if (!xf86LoadSubModule(pScrn, "shadowfb")) {
+	    SMI_FreeRec(pScrn);
+	    LEAVE_PROC("SMI_PreInit");
+	    return FALSE;
+	}
+	xf86LoaderReqSymLists(shadowSymbols, NULL);
+    }
+
+    LEAVE_PROC("SMI_PreInit");
+    return TRUE;
 }
 
 /*
@@ -1245,71 +1125,63 @@ SMI_PreInit(ScrnInfoPtr pScrn, int flags)
 static Bool
 SMI_EnterVT(int scrnIndex, int flags)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	Bool ret;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    Bool ret;
 
-	ENTER_PROC("SMI_EnterVT");
+    ENTER_PROC("SMI_EnterVT");
 
-	/* Enable MMIO and map memory */
-	SMI_MapMem(pScrn);
-	SMI_Save(pScrn);
+    /* Enable MMIO and map memory */
+    SMI_MapMem(pScrn);
+    SMI_Save(pScrn);
 
-	/* #670 */
-	if (pSmi->shadowFB)
-	{
-		pSmi->FBOffset = pSmi->savedFBOffset;
-		pSmi->FBReserved = pSmi->savedFBReserved;
-	}
+    /* #670 */
+    if (pSmi->shadowFB) {
+	pSmi->FBOffset = pSmi->savedFBOffset;
+	pSmi->FBReserved = pSmi->savedFBReserved;
+    }
 
-	ret = SMI_ModeInit(pScrn, pScrn->currentMode);
+    ret = SMI_ModeInit(pScrn, pScrn->currentMode);
 
-	/* #670 */
-	if (ret && pSmi->shadowFB)
-	{
-		BoxRec box;
-
-		/* #920 */
-		if (pSmi->paletteBuffer)
-		{
-			int i;
-
-			VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, 0);
-			for(i = 0; i < 256 * 3; i++)
-			{
-				VGAOUT8(pSmi, VGA_DAC_DATA, pSmi->paletteBuffer[i]);
-			}
-			xfree(pSmi->paletteBuffer);
-			pSmi->paletteBuffer = NULL;
-		}
+    /* #670 */
+    if (ret && pSmi->shadowFB) {
+	BoxRec box;
 
-		if (pSmi->pSaveBuffer)
-		{
-			memcpy(pSmi->FBBase, pSmi->pSaveBuffer, pSmi->saveBufferSize);
-			xfree(pSmi->pSaveBuffer);
-			pSmi->pSaveBuffer = NULL;
-		}
+	/* #920 */
+	if (pSmi->paletteBuffer) {
+	    int i;
 
-		box.x1 = 0;
-		box.y1 = 0;
-		box.x2 = pScrn->virtualY;
-		box.y2 = pScrn->virtualX;
-		if (pSmi->Chipset == SMI_COUGAR3DR)
-		{
-			SMI_RefreshArea730(pScrn, 1, &box);
-		}
-		else
-		{
-			SMI_RefreshArea(pScrn, 1, &box);
-		}
+	    VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, 0);
+	    for (i = 0; i < 256 * 3; i++) {
+		VGAOUT8(pSmi, VGA_DAC_DATA, pSmi->paletteBuffer[i]);
+	    }
+	    xfree(pSmi->paletteBuffer);
+	    pSmi->paletteBuffer = NULL;
+	}
+
+	if (pSmi->pSaveBuffer) {
+	    memcpy(pSmi->FBBase, pSmi->pSaveBuffer, pSmi->saveBufferSize);
+	    xfree(pSmi->pSaveBuffer);
+	    pSmi->pSaveBuffer = NULL;
+	}
+
+	box.x1 = 0;
+	box.y1 = 0;
+	box.x2 = pScrn->virtualY;
+	box.y2 = pScrn->virtualX;
+	if (pSmi->Chipset == SMI_COUGAR3DR) {
+	    SMI_RefreshArea730(pScrn, 1, &box);
+	} else {
+	    SMI_RefreshArea(pScrn, 1, &box);
 	}
+    }
 
-	/* Reset the grapics engine */
-	if (!pSmi->NoAccel)
-	    SMI_EngineReset(pScrn);
+    /* Reset the grapics engine */
+    if (!pSmi->NoAccel)
+	SMI_EngineReset(pScrn);
 
-	LEAVE_PROC("SMI_EnterVT");
-	return(ret);
+    LEAVE_PROC("SMI_EnterVT");
+    return ret;
 }
 
 /*
@@ -1321,48 +1193,43 @@ SMI_EnterVT(int scrnIndex, int flags)
 static void
 SMI_LeaveVT(int scrnIndex, int flags)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	vgaRegPtr vgaSavePtr = &hwp->SavedReg;
-	SMIRegPtr SMISavePtr = &pSmi->SavedReg;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    vgaRegPtr vgaSavePtr = &hwp->SavedReg;
+    SMIRegPtr SMISavePtr = &pSmi->SavedReg;
 
-	ENTER_PROC("SMI_LeaveVT");
+    ENTER_PROC("SMI_LeaveVT");
 
-	/* #670 */
-	if (pSmi->shadowFB)
-	{
-		pSmi->pSaveBuffer = xnfalloc(pSmi->saveBufferSize);
-		if (pSmi->pSaveBuffer)
-		{
-			memcpy(pSmi->pSaveBuffer, pSmi->FBBase, pSmi->saveBufferSize);
-		}
+    /* #670 */
+    if (pSmi->shadowFB) {
+	pSmi->pSaveBuffer = xnfalloc(pSmi->saveBufferSize);
+	if (pSmi->pSaveBuffer) {
+	    memcpy(pSmi->pSaveBuffer, pSmi->FBBase, pSmi->saveBufferSize);
+	}
+
+	pSmi->savedFBOffset = pSmi->FBOffset;
+	pSmi->savedFBReserved = pSmi->FBReserved;
 
-		pSmi->savedFBOffset = pSmi->FBOffset;
-		pSmi->savedFBReserved = pSmi->FBReserved;
-
-		/* #920 */
-		if (pSmi->Bpp == 1)
-		{
-			pSmi->paletteBuffer = xnfalloc(256 * 3);
-			if (pSmi->paletteBuffer)
-			{
-				int i;
-
-				VGAOUT8(pSmi, VGA_DAC_READ_ADDR, 0);
-				for (i = 0; i < 256 * 3; i++)
-				{
-					pSmi->paletteBuffer[i] = VGAIN8(pSmi, VGA_DAC_DATA);
-				}
-			}
+	/* #920 */
+	if (pSmi->Bpp == 1) {
+	    pSmi->paletteBuffer = xnfalloc(256 * 3);
+	    if (pSmi->paletteBuffer) {
+		int i;
+
+		VGAOUT8(pSmi, VGA_DAC_READ_ADDR, 0);
+		for (i = 0; i < 256 * 3; i++) {
+		    pSmi->paletteBuffer[i] = VGAIN8(pSmi, VGA_DAC_DATA);
 		}
+	    }
 	}
+    }
 
-	memset(pSmi->FBBase, 0, 256 * 1024);	/* #689 */
-	SMI_WriteMode(pScrn, vgaSavePtr, SMISavePtr);
-	SMI_UnmapMem(pScrn);
+    memset(pSmi->FBBase, 0, 256 * 1024);	/* #689 */
+    SMI_WriteMode(pScrn, vgaSavePtr, SMISavePtr);
+    SMI_UnmapMem(pScrn);
 
-	LEAVE_PROC("SMI_LeaveVT");
+    LEAVE_PROC("SMI_LeaveVT");
 }
 
 /*
@@ -1374,172 +1241,156 @@ SMI_LeaveVT(int scrnIndex, int flags)
 static void
 SMI_Save(ScrnInfoPtr pScrn)
 {
-	int i;
-	CARD32 offset;
-
-	vgaHWPtr hwp         = VGAHWPTR(pScrn);
-	vgaRegPtr vgaSavePtr = &hwp->SavedReg;
-	SMIPtr pSmi          = SMIPTR(pScrn);
-	SMIRegPtr save       = &pSmi->SavedReg;
-
-	int vgaIOBase  = hwp->IOBase;
-	int vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
-	int vgaCRData  = vgaIOBase + VGA_CRTC_DATA_OFFSET;
-
-	ENTER_PROC("SMI_Save");
-
-	/* Save the standard VGA registers */
-	vgaHWSave(pScrn, vgaSavePtr, VGA_SR_ALL);
-	save->smiDACMask = VGAIN8(pSmi, VGA_DAC_MASK);
-	VGAOUT8(pSmi, VGA_DAC_READ_ADDR, 0);
-	for (i = 0; i < 256; i++)
-	{
-		save->smiDacRegs[i][0] = VGAIN8(pSmi, VGA_DAC_DATA);
-		save->smiDacRegs[i][1] = VGAIN8(pSmi, VGA_DAC_DATA);
-		save->smiDacRegs[i][2] = VGAIN8(pSmi, VGA_DAC_DATA);
-	}
-	for (i = 0, offset = 2; i < 8192; i++, offset += 8)
-	{
-		save->smiFont[i] = *(pSmi->FBBase + offset);
-	}
-
-	/* Now we save all the extended registers we need. */
-	save->SR17 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x17);
-	save->SR18 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18);
-	save->SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
-	save->SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
-	save->SR32 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32);
-	save->SR6A = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A);
-	save->SR6B = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B);
-	save->SR81 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
-	save->SRA0 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0xA0);
-
-	if (pSmi->Dualhead) {
-	    /* dualhead stuff */
-	    save->SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22);
-	    save->SR40 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x40);
-	    save->SR41 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x41);
-	    save->SR42 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x42);
-	    save->SR43 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x43);
-	    save->SR44 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x44);
-	    save->SR45 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x45);
-	    save->SR48 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x48);
-	    save->SR49 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x49);
-	    save->SR4A = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4A);
-	    save->SR4B = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4B);
-	    save->SR4C = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4C);
-	    /* PLL stuff */
-	    save->SR68 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x68);
-	    save->SR69 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x69);
-	    save->SR6C = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6C);
-	    save->SR6D = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6D);
-	    save->SR6E = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6E);
-	    save->SR6F = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6F);
-	}
-
-	if (SMI_LYNXM_SERIES(pSmi->Chipset))
-	{
-		/* Save primary registers */
-		save->CR90[14] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E);
-		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
-				save->CR90[14] & ~0x20);
-
-		for (i = 0; i < 16; i++)
-		{
-			save->CR90[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x90 + i);
-		}
-		save->CR33 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
-		save->CR3A = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A);
-		for (i = 0; i < 14; i++)
-		{
-			save->CR40[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i);
-		}
-
-		/* Save secondary registers */
-		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, save->CR90[14] | 0x20);
-		save->CR33_2 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
-		for (i = 0; i < 14; i++)
-		{
-			save->CR40_2[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData,
-					0x40 + i);
-		}
-		save->CR9F_2 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F);
-
-		/* Save common registers */
-		for (i = 0; i < 14; i++)
-		{
-			save->CRA0[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0xA0 + i);
-		}
-
-		/* PDR#1069 */
-		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, save->CR90[14]);
-	}
-	else
-	{
-		save->CR33 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
-		save->CR3A = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A);
-		for (i = 0; i < 14; i++)
-		{
-			save->CR40[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i);
-		}
-	}
-
-	/* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
-	if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) {
-		save->CCR66 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
-	}
-	/* end CZ */
-
-	save->DPR10 = READ_DPR(pSmi, 0x10);
-	save->DPR1C = READ_DPR(pSmi, 0x1C);
-	save->DPR20 = READ_DPR(pSmi, 0x20);
-	save->DPR24 = READ_DPR(pSmi, 0x24);
-	save->DPR28 = READ_DPR(pSmi, 0x28);
-	save->DPR2C = READ_DPR(pSmi, 0x2C);
-	save->DPR30 = READ_DPR(pSmi, 0x30);
-	save->DPR3C = READ_DPR(pSmi, 0x3C);
-	save->DPR40 = READ_DPR(pSmi, 0x40);
-	save->DPR44 = READ_DPR(pSmi, 0x44);
-
-	save->VPR00 = READ_VPR(pSmi, 0x00);
-	save->VPR0C = READ_VPR(pSmi, 0x0C);
-	save->VPR10 = READ_VPR(pSmi, 0x10);
-
-	if (pSmi->Chipset == SMI_COUGAR3DR)
-	{
-		save->FPR00_ = READ_FPR(pSmi, FPR00); 
-		save->FPR0C_ = READ_FPR(pSmi, FPR0C);
-		save->FPR10_ = READ_FPR(pSmi, FPR10);
-	}
-
-	save->CPR00 = READ_CPR(pSmi, 0x00);
-
-	if (!pSmi->ModeStructInit)
-	{
-		/* XXX Should check the return value of vgaHWCopyReg() */
-		vgaHWCopyReg(&hwp->ModeReg, vgaSavePtr);
-		memcpy(&pSmi->ModeReg, save, sizeof(SMIRegRec));
-		pSmi->ModeStructInit = TRUE;
-	}
-
-	if (pSmi->useBIOS && (pSmi->pInt10 != NULL))
-	{
-		pSmi->pInt10->num = 0x10;
-		pSmi->pInt10->ax = 0x0F00;
-		xf86ExecX86int10(pSmi->pInt10);
-		save->mode = pSmi->pInt10->ax & 0x007F;
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Current mode 0x%02X.\n",
-				save->mode);
-	}
-
-	if (xf86GetVerbosity() > 1)
-	{
-		xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-				"Saved current video mode.  Register dump:\n");
-		SMI_PrintRegs(pScrn);
-	}
+    int i;
+    CARD32 offset;
+
+    vgaHWPtr hwp         = VGAHWPTR(pScrn);
+    vgaRegPtr vgaSavePtr = &hwp->SavedReg;
+    SMIPtr pSmi          = SMIPTR(pScrn);
+    SMIRegPtr save       = &pSmi->SavedReg;
+
+    int vgaIOBase  = hwp->IOBase;
+    int vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
+    int vgaCRData  = vgaIOBase + VGA_CRTC_DATA_OFFSET;
+
+    ENTER_PROC("SMI_Save");
+
+    /* Save the standard VGA registers */
+    vgaHWSave(pScrn, vgaSavePtr, VGA_SR_ALL);
+    save->smiDACMask = VGAIN8(pSmi, VGA_DAC_MASK);
+    VGAOUT8(pSmi, VGA_DAC_READ_ADDR, 0);
+    for (i = 0; i < 256; i++) {
+	save->smiDacRegs[i][0] = VGAIN8(pSmi, VGA_DAC_DATA);
+	save->smiDacRegs[i][1] = VGAIN8(pSmi, VGA_DAC_DATA);
+	save->smiDacRegs[i][2] = VGAIN8(pSmi, VGA_DAC_DATA);
+    }
+    for (i = 0, offset = 2; i < 8192; i++, offset += 8) {
+	save->smiFont[i] = *(pSmi->FBBase + offset);
+    }
+
+    /* Now we save all the extended registers we need. */
+    save->SR17 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x17);
+    save->SR18 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18);
+    save->SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
+    save->SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
+    save->SR32 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32);
+    save->SR6A = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A);
+    save->SR6B = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B);
+    save->SR81 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
+    save->SRA0 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0xA0);
+
+    if (pSmi->Dualhead) {
+	/* dualhead stuff */
+	save->SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22);
+	save->SR40 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x40);
+	save->SR41 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x41);
+	save->SR42 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x42);
+	save->SR43 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x43);
+	save->SR44 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x44);
+	save->SR45 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x45);
+	save->SR48 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x48);
+	save->SR49 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x49);
+	save->SR4A = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4A);
+	save->SR4B = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4B);
+	save->SR4C = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4C);
+	/* PLL stuff */
+	save->SR68 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x68);
+	save->SR69 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x69);
+	save->SR6C = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6C);
+	save->SR6D = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6D);
+	save->SR6E = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6E);
+	save->SR6F = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6F);
+    }
+
+    if (SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	/* Save primary registers */
+	save->CR90[14] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E);
+	VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, save->CR90[14] & ~0x20);
+
+	for (i = 0; i < 16; i++) {
+	    save->CR90[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x90 + i);
+	}
+	save->CR33 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
+	save->CR3A = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A);
+	for (i = 0; i < 14; i++) {
+	    save->CR40[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i);
+	}
+
+	/* Save secondary registers */
+	VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, save->CR90[14] | 0x20);
+	save->CR33_2 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
+	for (i = 0; i < 14; i++) {
+	    save->CR40_2[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i);
+	}
+	save->CR9F_2 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F);
+
+	/* Save common registers */
+	for (i = 0; i < 14; i++) {
+	    save->CRA0[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0xA0 + i);
+	}
+
+	/* PDR#1069 */
+	VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, save->CR90[14]);
+    } else {
+	save->CR33 = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33);
+	save->CR3A = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A);
+	for (i = 0; i < 14; i++) {
+	    save->CR40[i] = VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i);
+	}
+    }
+
+    /* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
+    if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) {
+	save->CCR66 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
+    }
+    /* end CZ */
+
+    save->DPR10 = READ_DPR(pSmi, 0x10);
+    save->DPR1C = READ_DPR(pSmi, 0x1C);
+    save->DPR20 = READ_DPR(pSmi, 0x20);
+    save->DPR24 = READ_DPR(pSmi, 0x24);
+    save->DPR28 = READ_DPR(pSmi, 0x28);
+    save->DPR2C = READ_DPR(pSmi, 0x2C);
+    save->DPR30 = READ_DPR(pSmi, 0x30);
+    save->DPR3C = READ_DPR(pSmi, 0x3C);
+    save->DPR40 = READ_DPR(pSmi, 0x40);
+    save->DPR44 = READ_DPR(pSmi, 0x44);
+
+    save->VPR00 = READ_VPR(pSmi, 0x00);
+    save->VPR0C = READ_VPR(pSmi, 0x0C);
+    save->VPR10 = READ_VPR(pSmi, 0x10);
+
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
+	save->FPR00_ = READ_FPR(pSmi, FPR00); 
+	save->FPR0C_ = READ_FPR(pSmi, FPR0C);
+	save->FPR10_ = READ_FPR(pSmi, FPR10);
+    }
+
+    save->CPR00 = READ_CPR(pSmi, 0x00);
+
+    if (!pSmi->ModeStructInit) {
+	/* XXX Should check the return value of vgaHWCopyReg() */
+	vgaHWCopyReg(&hwp->ModeReg, vgaSavePtr);
+	memcpy(&pSmi->ModeReg, save, sizeof(SMIRegRec));
+	pSmi->ModeStructInit = TRUE;
+    }
+
+    if (pSmi->useBIOS && (pSmi->pInt10 != NULL)) {
+	pSmi->pInt10->num = 0x10;
+	pSmi->pInt10->ax = 0x0F00;
+	xf86ExecX86int10(pSmi->pInt10);
+	save->mode = pSmi->pInt10->ax & 0x007F;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Current mode 0x%02X.\n",
+		   save->mode);
+    }
+
+    if (xf86GetVerbosity() > 1) {
+	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		       "Saved current video mode.  Register dump:\n");
+	SMI_PrintRegs(pScrn);
+    }
 
-	LEAVE_PROC("SMI_Save");
+    LEAVE_PROC("SMI_Save");
 }
 
 /*
@@ -1550,150 +1401,128 @@ SMI_Save(ScrnInfoPtr pScrn)
 static void
 SMI_WriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr, SMIRegPtr restore)
 {
-	int i;
-	CARD8 tmp;
-	CARD32 offset;
+    int i;
+    CARD8 tmp;
+    CARD32 offset;
 
-	vgaHWPtr hwp   = VGAHWPTR(pScrn);
-	SMIPtr pSmi    = SMIPTR(pScrn);
-	int vgaIOBase  = hwp->IOBase;
-	int vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
-	int vgaCRData  = vgaIOBase + VGA_CRTC_DATA_OFFSET;
+    vgaHWPtr hwp   = VGAHWPTR(pScrn);
+    SMIPtr pSmi    = SMIPTR(pScrn);
+    int vgaIOBase  = hwp->IOBase;
+    int vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
+    int vgaCRData  = vgaIOBase + VGA_CRTC_DATA_OFFSET;
 
-	ENTER_PROC("SMI_WriteMode");
+    ENTER_PROC("SMI_WriteMode");
 
-	vgaHWProtect(pScrn, TRUE);
+    vgaHWProtect(pScrn, TRUE);
 
-	/* Wait for engine to become idle */
-	if (pSmi->IsSwitching)
-	    WaitIdle();
+    /* Wait for engine to become idle */
+    if (pSmi->IsSwitching)
+	WaitIdle();
 
-	if (pSmi->useBIOS && (pSmi->pInt10 != NULL)
-	    && (restore->mode != 0))
-	{
-		pSmi->pInt10->num = 0x10;
-		pSmi->pInt10->ax = restore->mode | 0x80;
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Setting mode 0x%02X\n",
-				restore->mode);
-		xf86ExecX86int10(pSmi->pInt10);
+    if (pSmi->useBIOS && (pSmi->pInt10 != NULL) && (restore->mode != 0)) {
+	pSmi->pInt10->num = 0x10;
+	pSmi->pInt10->ax = restore->mode | 0x80;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Setting mode 0x%02X\n",
+		   restore->mode);
+	xf86ExecX86int10(pSmi->pInt10);
 
-		/* Enable linear mode. */
-		outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
-		tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
-		outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp | 0x01);
+	/* Enable linear mode. */
+	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
+	tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
+	outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp | 0x01);
+
+	/* Enable DPR/VPR registers. */
+	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, tmp & ~0x03);
+    } else {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x17, restore->SR17);
+	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18) & ~0x1F;
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18, tmp |
+		      (restore->SR18 & 0x1F));
+	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, tmp & ~0x03);
+	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31) & ~0xC0;
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31, tmp |
+		      (restore->SR31 & 0xC0));
+	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32) & ~0x07;
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32, tmp |
+		      (restore->SR32 & 0x07));
+	if (restore->SR6B != 0xFF) {
+	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A, restore->SR6A);
+	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B, restore->SR6B);
+	}
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, restore->SR81);
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0xA0, restore->SRA0);
+
+	/* Restore the standard VGA registers */
+	vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_ALL);
+	if (restore->smiDACMask) {
+	    VGAOUT8(pSmi, VGA_DAC_MASK, restore->smiDACMask);
+	} else {
+	    VGAOUT8(pSmi, VGA_DAC_MASK, 0xFF);
+	}
+	VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, 0);
+	for (i = 0; i < 256; i++) {
+	    VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][0]);
+	    VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][1]);
+	    VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][2]);
+	}
+	for (i = 0, offset = 2; i < 8192; i++, offset += 8) {
+	    *(pSmi->FBBase + offset) = restore->smiFont[i];
+	}
+
+	if (SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	    /* Restore secondary registers */
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
+			  restore->CR90[14] | 0x20);
+
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33_2);
+	    for (i = 0; i < 14; i++) {
+		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
+			      restore->CR40_2[i]);
+	    }
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F, restore->CR9F_2);
 
-		/* Enable DPR/VPR registers. */
-		tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, tmp & ~0x03);
-	}
-	else
-	{
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x17, restore->SR17);
-		tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18) & ~0x1F;
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18, tmp |
-				(restore->SR18 & 0x1F));
-		tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, tmp & ~0x03);
-		tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31) & ~0xC0;
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31, tmp |
-				(restore->SR31 & 0xC0));
-		tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32) & ~0x07;
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32, tmp |
-				(restore->SR32 & 0x07));
-		if (restore->SR6B != 0xFF)
-		{
-			VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A,
-					restore->SR6A);
-			VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B,
-					restore->SR6B);
-		}
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, restore->SR81);
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0xA0, restore->SRA0);
-
-		/* Restore the standard VGA registers */
-		vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_ALL);
-		if (restore->smiDACMask)
-		{
-			VGAOUT8(pSmi, VGA_DAC_MASK, restore->smiDACMask);
-		}
-		else
-		{
-			VGAOUT8(pSmi, VGA_DAC_MASK, 0xFF);
-		}
-		VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, 0);
-		for (i = 0; i < 256; i++)
-		{
-			VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][0]);
-			VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][1]);
-			VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][2]);
-		}
-		for (i = 0, offset = 2; i < 8192; i++, offset += 8)
-		{
-			*(pSmi->FBBase + offset) = restore->smiFont[i];
-		}
+	    /* Restore primary registers */
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
+			  restore->CR90[14] & ~0x20);
 
-		if (SMI_LYNXM_SERIES(pSmi->Chipset))
-		{
-			/* Restore secondary registers */
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
-					restore->CR90[14] | 0x20);
-
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33_2);
-			for (i = 0; i < 14; i++)
-			{
-				VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
-						restore->CR40_2[i]);
-			}
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F, restore->CR9F_2);
-
-			/* Restore primary registers */
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
-					restore->CR90[14] & ~0x20);
-
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
-			for (i = 0; i < 14; i++)
-			{
-				VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
-						restore->CR40[i]);
-			}
-			for (i = 0; i < 16; i++)
-			{
-				if (i != 14)
-				{
-					VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x90 + i,
-							restore->CR90[i]);
-				}
-			}
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, restore->CR90[14]);
-
-			/* Restore common registers */
-			for (i = 0; i < 14; i++)
-			{
-				VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0xA0 + i,
-						restore->CRA0[i]);
-			}
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
+	    for (i = 0; i < 14; i++) {
+		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
+			      restore->CR40[i]);
+	    }
+	    for (i = 0; i < 16; i++) {
+		if (i != 14) {
+		    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x90 + i,
+				  restore->CR90[i]);
 		}
+	    }
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E, restore->CR90[14]);
 
-		/* Restore the standard VGA registers */
-		if (xf86IsPrimaryPci(pSmi->PciInfo)) {
-		    vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_CMAP 
-				 | VGA_SR_FONTS);
-		} 
-
-		if (restore->modeInit)
-		    vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_ALL);
-
-		if (!SMI_LYNXM_SERIES(pSmi->Chipset))
-		{
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
-			VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
-			for (i = 0; i < 14; i++)
-			{
-				VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
-						restore->CR40[i]);
-			}
-		}
+	    /* Restore common registers */
+	    for (i = 0; i < 14; i++) {
+		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0xA0 + i,
+			      restore->CRA0[i]);
+	    }
+	}
+
+	/* Restore the standard VGA registers */
+	if (xf86IsPrimaryPci(pSmi->PciInfo)) {
+	    vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_CMAP | VGA_SR_FONTS);
+	} 
+
+	if (restore->modeInit)
+	    vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_ALL);
+
+	if (!SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
+	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
+	    for (i = 0; i < 14; i++) {
+		VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
+			      restore->CR40[i]);
+	    }
 	}
 
 	if (pSmi->Dualhead) {
@@ -1742,377 +1571,331 @@ SMI_WriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr, SMIRegPtr restore)
 	    VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
 
 	}
+    }
 
-	/* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
-	if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) {
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66, restore->CCR66);
-	}
-	/* end CZ */
+    /* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
+    if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66, restore->CCR66);
+    }
+    /* end CZ */
 
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, 0x00);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, 0x00);
 
-	/* Reset the graphics engine */
-	WRITE_DPR(pSmi, 0x10, restore->DPR10);
-	WRITE_DPR(pSmi, 0x1C, restore->DPR1C);
-	WRITE_DPR(pSmi, 0x20, restore->DPR20);
-	WRITE_DPR(pSmi, 0x24, restore->DPR24);
-	WRITE_DPR(pSmi, 0x28, restore->DPR28);
-	WRITE_DPR(pSmi, 0x2C, restore->DPR2C);
-	WRITE_DPR(pSmi, 0x30, restore->DPR30);
-	WRITE_DPR(pSmi, 0x3C, restore->DPR3C);
-	WRITE_DPR(pSmi, 0x40, restore->DPR40);
-	WRITE_DPR(pSmi, 0x44, restore->DPR44);
+    /* Reset the graphics engine */
+    WRITE_DPR(pSmi, 0x10, restore->DPR10);
+    WRITE_DPR(pSmi, 0x1C, restore->DPR1C);
+    WRITE_DPR(pSmi, 0x20, restore->DPR20);
+    WRITE_DPR(pSmi, 0x24, restore->DPR24);
+    WRITE_DPR(pSmi, 0x28, restore->DPR28);
+    WRITE_DPR(pSmi, 0x2C, restore->DPR2C);
+    WRITE_DPR(pSmi, 0x30, restore->DPR30);
+    WRITE_DPR(pSmi, 0x3C, restore->DPR3C);
+    WRITE_DPR(pSmi, 0x40, restore->DPR40);
+    WRITE_DPR(pSmi, 0x44, restore->DPR44);
 
-	/* write video controller regs */
-	WRITE_VPR(pSmi, 0x00, restore->VPR00);
-	WRITE_VPR(pSmi, 0x0C, restore->VPR0C);
-	WRITE_VPR(pSmi, 0x10, restore->VPR10);
+    /* write video controller regs */
+    WRITE_VPR(pSmi, 0x00, restore->VPR00);
+    WRITE_VPR(pSmi, 0x0C, restore->VPR0C);
+    WRITE_VPR(pSmi, 0x10, restore->VPR10);
 
-	if(pSmi->Chipset == SMI_COUGAR3DR)
-	{
-		WRITE_FPR(pSmi, FPR00, restore->FPR00_);
-		WRITE_FPR(pSmi, FPR0C, restore->FPR0C_);
-		WRITE_FPR(pSmi, FPR10, restore->FPR10_);
-	}
+    if(pSmi->Chipset == SMI_COUGAR3DR) {
+	WRITE_FPR(pSmi, FPR00, restore->FPR00_);
+	WRITE_FPR(pSmi, FPR0C, restore->FPR0C_);
+	WRITE_FPR(pSmi, FPR10, restore->FPR10_);
+    }
 
-	WRITE_CPR(pSmi, 0x00, restore->CPR00);
+    WRITE_CPR(pSmi, 0x00, restore->CPR00);
 
-	if (xf86GetVerbosity() > 1)
-	{
-		xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-				"Done restoring mode.  Register dump:\n");
-		SMI_PrintRegs(pScrn);
-	}
+    if (xf86GetVerbosity() > 1) {
+	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		       "Done restoring mode.  Register dump:\n");
+	SMI_PrintRegs(pScrn);
+    }
 
-	vgaHWProtect(pScrn, FALSE);
+    vgaHWProtect(pScrn, FALSE);
 
-	LEAVE_PROC("SMI_WriteMode");
+    LEAVE_PROC("SMI_WriteMode");
 }
 
 static void
 SMI_DetectPanelSize(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	/* panel size detection ... requires BIOS call on 730 hardware */
-	if (pSmi->Chipset == SMI_COUGAR3DR)
-	{
-		if (pSmi->pInt10 != NULL)
-		{
-			pSmi->pInt10->num = 0x10;
-			pSmi->pInt10->ax  = 0x5F00;
-			pSmi->pInt10->bx  = 0;
-			pSmi->pInt10->cx  = 0;
-			pSmi->pInt10->dx  = 0;
-			xf86ExecX86int10(pSmi->pInt10);
-			if (pSmi->pInt10->ax == 0x005F)
-			{
-				switch (pSmi->pInt10->cx & 0x0F)
-				{
-					case PANEL_640x480:
-						pSmi->lcdWidth  = 640;
-						pSmi->lcdHeight = 480;
-						break;
-					
-					case PANEL_800x600:
-						pSmi->lcdWidth  = 800;
-						pSmi->lcdHeight = 600;
-						break;
-					
-					case PANEL_1024x768:
-						pSmi->lcdWidth  = 1024;
-						pSmi->lcdHeight = 768;
-						break;
-					
-					case PANEL_1280x1024:
-						pSmi->lcdWidth  = 1280;
-						pSmi->lcdHeight = 1024;
-						break;
-					
-					case PANEL_1600x1200:
-						pSmi->lcdWidth  = 1600;
-						pSmi->lcdHeight = 1200;
-						break;
-					
-					case PANEL_1400x1050:
-						pSmi->lcdWidth  = 1400;
-						pSmi->lcdHeight = 1050;
-						break;
-				}
-	
-				xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Detected panel size via BIOS: %d x %d\n",
-					   pSmi->lcdWidth, pSmi->lcdHeight);
-			}
-			else
-			{
-				xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BIOS error during 730 panel detection!\n");
-				pSmi->lcdWidth  = pScrn->virtualX;
-				pSmi->lcdHeight = pScrn->virtualY;
-			}
-		}
-		else 
-		{
-			/* int10 support isn't setup on the second call to this function,
-			   so if this is the second call, don't do detection again */
-			if (pSmi->lcd == 0)
-			{
-				/* If we get here, int10 support is not loaded or not working */ 
-				xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No BIOS support for 730 panel detection!\n");
-				pSmi->lcdWidth  = pScrn->virtualX;
-				pSmi->lcdHeight = pScrn->virtualY;
-			}
-		}
-
-		/* Set this to indicate that we've done the detection */
-		pSmi->lcd = 1;
-	}
-	else /* panel size detection for hardware other than 730 */
-	{
-		pSmi->lcd = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31) & 0x01;
-	
-		if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x01)
-		{
-			pSmi->lcd <<= 1;
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    /* panel size detection ... requires BIOS call on 730 hardware */
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
+	if (pSmi->pInt10 != NULL) {
+	    pSmi->pInt10->num = 0x10;
+	    pSmi->pInt10->ax  = 0x5F00;
+	    pSmi->pInt10->bx  = 0;
+	    pSmi->pInt10->cx  = 0;
+	    pSmi->pInt10->dx  = 0;
+	    xf86ExecX86int10(pSmi->pInt10);
+	    if (pSmi->pInt10->ax == 0x005F) {
+		switch (pSmi->pInt10->cx & 0x0F) {
+		case PANEL_640x480:
+		    pSmi->lcdWidth  = 640;
+		    pSmi->lcdHeight = 480;
+		    break;
+		case PANEL_800x600:
+		    pSmi->lcdWidth  = 800;
+		    pSmi->lcdHeight = 600;
+		    break;
+		case PANEL_1024x768:
+		    pSmi->lcdWidth  = 1024;
+		    pSmi->lcdHeight = 768;
+		    break;
+		case PANEL_1280x1024:
+		    pSmi->lcdWidth  = 1280;
+		    pSmi->lcdHeight = 1024;
+		    break;
+		case PANEL_1600x1200:
+		    pSmi->lcdWidth  = 1600;
+		    pSmi->lcdHeight = 1200;
+		    break;
+		case PANEL_1400x1050:
+		    pSmi->lcdWidth  = 1400;
+		    pSmi->lcdHeight = 1050;
+		    break;
 		}
-		switch (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x0C)
-		{
-			case 0x00:
-				pSmi->lcdWidth  = 640;
-				pSmi->lcdHeight = 480;
-				break;
-	
-			case 0x04:
-				pSmi->lcdWidth  = 800;
-				pSmi->lcdHeight = 600;
-				break;
 	
-			case 0x08:
-				if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x74) & 0x02)
-				{
-					pSmi->lcdWidth  = 1024;
-					pSmi->lcdHeight = 600;
-				}
-				else
-				{
-					pSmi->lcdWidth  = 1024;
-					pSmi->lcdHeight = 768;
-				}
-				break;
+		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Detected panel size via BIOS: %d x %d\n",
+			   pSmi->lcdWidth, pSmi->lcdHeight);
+	    } else {
+		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "BIOS error during 730 panel detection!\n");
+			   pSmi->lcdWidth  = pScrn->virtualX;
+		pSmi->lcdHeight = pScrn->virtualY;
+	    }
+	} else  {
+	    /* int10 support isn't setup on the second call to this function,
+	       so if this is the second call, don't do detection again */
+	    if (pSmi->lcd == 0) {
+		/* If we get here, int10 support is not loaded or not working */ 
+		xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No BIOS support for 730 panel detection!\n");
+		pSmi->lcdWidth  = pScrn->virtualX;
+		pSmi->lcdHeight = pScrn->virtualY;
+	    }
+	}
+
+	/* Set this to indicate that we've done the detection */
+	pSmi->lcd = 1;
+    } else {
+	/* panel size detection for hardware other than 730 */
+	pSmi->lcd = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31) & 0x01;
 	
-			case 0x0C:
-				pSmi->lcdWidth  = 1280;
-				pSmi->lcdHeight = 1024;
-				break;
-		}
+	if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x01) {
+	    pSmi->lcd <<= 1;
+	}
+	switch (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x0C) {
+	case 0x00:
+	    pSmi->lcdWidth  = 640;
+	    pSmi->lcdHeight = 480;
+	    break;
+	case 0x04:
+	    pSmi->lcdWidth  = 800;
+	    pSmi->lcdHeight = 600;
+	    break;
+	case 0x08:
+	    if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x74) & 0x02) {
+		pSmi->lcdWidth  = 1024;
+		pSmi->lcdHeight = 600;
+	    } else {
+		pSmi->lcdWidth  = 1024;
+		pSmi->lcdHeight = 768;
+	    }
+	    break;
+	case 0x0C:
+	    pSmi->lcdWidth  = 1280;
+	    pSmi->lcdHeight = 1024;
+	    break;
 	}
+    }
 
-	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%s Panel Size = %dx%d\n",
-			(pSmi->lcd == 0) ? "OFF" : (pSmi->lcd == 1) ? "TFT" : "DSTN",
-			pSmi->lcdWidth, pSmi->lcdHeight);
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%s Panel Size = %dx%d\n",
+	       (pSmi->lcd == 0) ? "OFF" : (pSmi->lcd == 1) ? "TFT" : "DSTN",
+	       pSmi->lcdWidth, pSmi->lcdHeight);
 
 }
 
 static Bool
 SMI_MapMem(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	vgaHWPtr hwp;
-	CARD32 memBase;
-
-	ENTER_PROC("SMI_MapMem");
-
-	/* Map the Lynx register space */
-	switch (pSmi->Chipset)
-	{
-		default:
-			memBase = pSmi->PciInfo->memBase[0] + 0x400000;
-			pSmi->MapSize = 0x10000;
-			break;
-
-		case SMI_COUGAR3DR:
-			memBase = pSmi->PciInfo->memBase[1];
-			pSmi->MapSize = 0x200000;
-			break;
-
-		case SMI_LYNX3D:
-			memBase = pSmi->PciInfo->memBase[0] + 0x680000;
-			pSmi->MapSize = 0x180000;
-			break;
-
-		case SMI_LYNXEM:
-		case SMI_LYNXEMplus:
-			memBase = pSmi->PciInfo->memBase[0] + 0x400000;
-			pSmi->MapSize = 0x400000;
-			break;
-
-		case SMI_LYNX3DM:
-			memBase = pSmi->PciInfo->memBase[0];
-			pSmi->MapSize = 0x200000;
-			break;
-	}
-	pSmi->MapBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO, pSmi->PciTag,
-			memBase, pSmi->MapSize);
-
-	if (pSmi->MapBase == NULL)
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Internal error: could not map "
-				"MMIO registers.\n");
-		LEAVE_PROC("SMI_MapMem");
-		return(FALSE);
-	}
-
-	switch (pSmi->Chipset)
-	{
-		default:
-			pSmi->DPRBase = pSmi->MapBase + 0x8000;
-			pSmi->VPRBase = pSmi->MapBase + 0xC000;
-			pSmi->CPRBase = pSmi->MapBase + 0xE000;
-			pSmi->IOBase  = NULL;
-			pSmi->DataPortBase = pSmi->MapBase;
-			pSmi->DataPortSize = 0x8000;
-			break;
-
-		case SMI_COUGAR3DR:
-			pSmi->DPRBase = pSmi->MapBase + 0x000000;
-			pSmi->VPRBase = pSmi->MapBase + 0x000800;
-			pSmi->CPRBase = pSmi->MapBase + 0x001000;
-			pSmi->FPRBase = pSmi->MapBase + 0x005800;
-			pSmi->IOBase  = pSmi->MapBase + 0x0C0000;
-			pSmi->DataPortBase = pSmi->MapBase + 0x100000;
-			pSmi->DataPortSize = 0x100000;
-			break;
-
-		case SMI_LYNX3D:
-			pSmi->DPRBase = pSmi->MapBase + 0x000000;
-			pSmi->VPRBase = pSmi->MapBase + 0x000800;
-			pSmi->CPRBase = pSmi->MapBase + 0x001000;
-			pSmi->IOBase  = pSmi->MapBase + 0x040000;
-			pSmi->DataPortBase = pSmi->MapBase + 0x080000;
-			pSmi->DataPortSize = 0x100000;
-			break;
-
-		case SMI_LYNXEM:
-		case SMI_LYNXEMplus:
-			pSmi->DPRBase = pSmi->MapBase + 0x008000;
-			pSmi->VPRBase = pSmi->MapBase + 0x00C000;
-			pSmi->CPRBase = pSmi->MapBase + 0x00E000;
-			pSmi->IOBase  = pSmi->MapBase + 0x300000;
-			pSmi->DataPortBase = pSmi->MapBase /*+ 0x100000*/;
-			pSmi->DataPortSize = 0x8000 /*0x200000*/;
-			break;
-
-		case SMI_LYNX3DM:
-			pSmi->DPRBase = pSmi->MapBase + 0x000000;
-			pSmi->VPRBase = pSmi->MapBase + 0x000800;
-			pSmi->CPRBase = pSmi->MapBase + 0x001000;
-			pSmi->IOBase  = pSmi->MapBase + 0x0C0000;
-			pSmi->DataPortBase = pSmi->MapBase + 0x100000;
-			pSmi->DataPortSize = 0x100000;
-			break;
-	}
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"Physical MMIO at 0x%08lX\n", (unsigned long)memBase);
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"Logical MMIO at %p - %p\n", pSmi->MapBase,
-			pSmi->MapBase + pSmi->MapSize - 1);
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"DPR=%p, VPR=%p, IOBase=%p\n",
-			pSmi->DPRBase, pSmi->VPRBase, pSmi->IOBase);
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"DataPort=%p - %p\n", pSmi->DataPortBase,
-			pSmi->DataPortBase + pSmi->DataPortSize - 1);
-
-	pScrn->memPhysBase = pSmi->PciInfo->memBase[0];
-
-	SMI_EnableMmio(pScrn);
-
-	if (pSmi->videoRAMBytes) {
-
-	    /* Map the frame buffer */
-	    if (pSmi->Chipset == SMI_LYNX3DM) 
-	        pSmi->fbMapOffset = 0x200000;
-	    else
-	        pSmi->fbMapOffset = 0x0;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    vgaHWPtr hwp;
+    CARD32 memBase;
+
+    ENTER_PROC("SMI_MapMem");
+
+    /* Map the Lynx register space */
+    switch (pSmi->Chipset) {
+    default:
+	memBase = pSmi->PciInfo->memBase[0] + 0x400000;
+	pSmi->MapSize = 0x10000;
+	break;
+    case SMI_COUGAR3DR:
+	memBase = pSmi->PciInfo->memBase[1];
+	pSmi->MapSize = 0x200000;
+	break;
+    case SMI_LYNX3D:
+	memBase = pSmi->PciInfo->memBase[0] + 0x680000;
+	pSmi->MapSize = 0x180000;
+	break;
+    case SMI_LYNXEM:
+    case SMI_LYNXEMplus:
+	memBase = pSmi->PciInfo->memBase[0] + 0x400000;
+	pSmi->MapSize = 0x400000;
+	break;
+    case SMI_LYNX3DM:
+	memBase = pSmi->PciInfo->memBase[0];
+	pSmi->MapSize = 0x200000;
+	break;
+    }
+    pSmi->MapBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO, pSmi->PciTag,
+				  memBase, pSmi->MapSize);
+
+    if (pSmi->MapBase == NULL) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Internal error: could not map "
+		   "MMIO registers.\n");
+	LEAVE_PROC("SMI_MapMem");
+	return FALSE;
+    }
+
+    switch (pSmi->Chipset) {
+    default:
+	pSmi->DPRBase = pSmi->MapBase + 0x8000;
+	pSmi->VPRBase = pSmi->MapBase + 0xC000;
+	pSmi->CPRBase = pSmi->MapBase + 0xE000;
+	pSmi->IOBase  = NULL;
+	pSmi->DataPortBase = pSmi->MapBase;
+	pSmi->DataPortSize = 0x8000;
+	break;
+    case SMI_COUGAR3DR:
+	pSmi->DPRBase = pSmi->MapBase + 0x000000;
+	pSmi->VPRBase = pSmi->MapBase + 0x000800;
+	pSmi->CPRBase = pSmi->MapBase + 0x001000;
+	pSmi->FPRBase = pSmi->MapBase + 0x005800;
+	pSmi->IOBase  = pSmi->MapBase + 0x0C0000;
+	pSmi->DataPortBase = pSmi->MapBase + 0x100000;
+	pSmi->DataPortSize = 0x100000;
+	break;
+    case SMI_LYNX3D:
+	pSmi->DPRBase = pSmi->MapBase + 0x000000;
+	pSmi->VPRBase = pSmi->MapBase + 0x000800;
+	pSmi->CPRBase = pSmi->MapBase + 0x001000;
+	pSmi->IOBase  = pSmi->MapBase + 0x040000;
+	pSmi->DataPortBase = pSmi->MapBase + 0x080000;
+	pSmi->DataPortSize = 0x100000;
+	break;
+    case SMI_LYNXEM:
+    case SMI_LYNXEMplus:
+	pSmi->DPRBase = pSmi->MapBase + 0x008000;
+	pSmi->VPRBase = pSmi->MapBase + 0x00C000;
+	pSmi->CPRBase = pSmi->MapBase + 0x00E000;
+	pSmi->IOBase  = pSmi->MapBase + 0x300000;
+	pSmi->DataPortBase = pSmi->MapBase /*+ 0x100000*/;
+	pSmi->DataPortSize = 0x8000 /*0x200000*/;
+	break;
+    case SMI_LYNX3DM:
+	pSmi->DPRBase = pSmi->MapBase + 0x000000;
+	pSmi->VPRBase = pSmi->MapBase + 0x000800;
+	pSmi->CPRBase = pSmi->MapBase + 0x001000;
+	pSmi->IOBase  = pSmi->MapBase + 0x0C0000;
+	pSmi->DataPortBase = pSmi->MapBase + 0x100000;
+	pSmi->DataPortSize = 0x100000;
+	break;
+    }
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		   "Physical MMIO at 0x%08lX\n", (unsigned long)memBase);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		   "Logical MMIO at %p - %p\n", pSmi->MapBase,
+		   pSmi->MapBase + pSmi->MapSize - 1);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		   "DPR=%p, VPR=%p, IOBase=%p\n",
+		   pSmi->DPRBase, pSmi->VPRBase, pSmi->IOBase);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		   "DataPort=%p - %p\n", pSmi->DataPortBase,
+		   pSmi->DataPortBase + pSmi->DataPortSize - 1);
+
+    pScrn->memPhysBase = pSmi->PciInfo->memBase[0];
+
+    SMI_EnableMmio(pScrn);
+
+    if (pSmi->videoRAMBytes) {
+	/* Map the frame buffer */
+	if (pSmi->Chipset == SMI_LYNX3DM) 
+	    pSmi->fbMapOffset = 0x200000;
+	else
+	    pSmi->fbMapOffset = 0x0;
 
-	    pSmi->FBOffset = 0;
+	pSmi->FBOffset = 0;
 
-	    pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
+	pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
 
-	    pSmi->FBBase = xf86MapPciMem(pScrn->scrnIndex,
-					 VIDMEM_FRAMEBUFFER,
-					 pSmi->PciTag,
-					 pScrn->memPhysBase + pSmi->fbMapOffset,
-					 pSmi->videoRAMBytes);
+	pSmi->FBBase = xf86MapPciMem(pScrn->scrnIndex,
+				     VIDMEM_FRAMEBUFFER,
+				     pSmi->PciTag,
+				     pScrn->memPhysBase + pSmi->fbMapOffset,
+				     pSmi->videoRAMBytes);
 	    
-		if (pSmi->FBBase == NULL)
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Internal error: could not "
-					"map framebuffer.\n");
-			LEAVE_PROC("SMI_MapMem");
-			return(FALSE);
-		}
-
-		xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"Physical frame buffer at 0x%08lX offset: 0x%08lX\n",
-		       pScrn->memPhysBase, pScrn->fbOffset);
-		xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"Logical frame buffer at %p - %p\n", pSmi->FBBase,
-			pSmi->FBBase + pSmi->videoRAMBytes - 1);
-
-		/* Set up offset to hwcursor memory area.  It's a 1K chunk at the end of
-		 * the frame buffer.
-		 */
-		pSmi->FBCursorOffset = pSmi->videoRAMBytes - 1024;
-
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-			"Cursor Offset: %08lX\n",
-			(unsigned long)pSmi->FBCursorOffset);
-
-		/* set up the fifo reserved space */
-		if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x01)/* #1074 */
-		{
-			CARD32 fifoOffset = 0;
-			fifoOffset |= VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x46)
-				<< 3;
-			fifoOffset |= VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x47)
-				<< 11;
-			fifoOffset |= (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x49)
-				& 0x1C) << 17;
-			pSmi->FBReserved = fifoOffset;	/* PDR#1074 */
-		}
-		else
-		{
-			pSmi->FBReserved = pSmi->videoRAMBytes - 2048;
-		}
-
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-			"Reserved: %08lX\n",
-			   (unsigned long)pSmi->FBReserved);
-
-	}
-
-	/* Assign hwp->MemBase & IOBase here */
-	hwp = VGAHWPTR(pScrn);
-	if (pSmi->IOBase != NULL)
-	{
-		vgaHWSetMmioFuncs(hwp, pSmi->MapBase, pSmi->IOBase - pSmi->MapBase);
+	if (pSmi->FBBase == NULL) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Internal error: could not "
+		       "map framebuffer.\n");
+	    LEAVE_PROC("SMI_MapMem");
+	    return FALSE;
 	}
-	vgaHWGetIOBase(hwp);
 
-	/* Map the VGA memory when the primary video */
-	if (xf86IsPrimaryPci(pSmi->PciInfo))
-	{
-		hwp->MapSize = 0x10000;
-		if (!vgaHWMapMem(pScrn))
-		{
-			LEAVE_PROC("SMI_MapMem");
-			return(FALSE);
-		}
-		pSmi->PrimaryVidMapped = TRUE;
-	}
+	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		       "Physical frame buffer at 0x%08lX offset: 0x%08lX\n",
+		       pScrn->memPhysBase, pScrn->fbOffset);
+	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		       "Logical frame buffer at %p - %p\n", pSmi->FBBase,
+		       pSmi->FBBase + pSmi->videoRAMBytes - 1);
 
-	LEAVE_PROC("SMI_MapMem");
-	return(TRUE);
+	/* Set up offset to hwcursor memory area.  It's a 1K chunk at the end of
+	 * the frame buffer.
+	 */
+	pSmi->FBCursorOffset = pSmi->videoRAMBytes - 1024;
+
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		   "Cursor Offset: %08lX\n",
+		   (unsigned long)pSmi->FBCursorOffset);
+
+	/* set up the fifo reserved space */
+	if (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x30) & 0x01)/* #1074 */ {
+	    CARD32 fifoOffset = 0;
+	    fifoOffset |= VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x46) << 3;
+	    fifoOffset |= VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x47) << 11;
+	    fifoOffset |= (VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x49)
+			& 0x1C) << 17;
+	    pSmi->FBReserved = fifoOffset;	/* PDR#1074 */
+	} else {
+	    pSmi->FBReserved = pSmi->videoRAMBytes - 2048;
+	}
+
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Reserved: %08lX\n",
+		   (unsigned long)pSmi->FBReserved);
+
+    }
+
+    /* Assign hwp->MemBase & IOBase here */
+    hwp = VGAHWPTR(pScrn);
+    if (pSmi->IOBase != NULL) {
+	vgaHWSetMmioFuncs(hwp, pSmi->MapBase, pSmi->IOBase - pSmi->MapBase);
+    }
+    vgaHWGetIOBase(hwp);
+
+    /* Map the VGA memory when the primary video */
+    if (xf86IsPrimaryPci(pSmi->PciInfo)) {
+	hwp->MapSize = 0x10000;
+	if (!vgaHWMapMem(pScrn)) {
+	    LEAVE_PROC("SMI_MapMem");
+	    return FALSE;
+	}
+	pSmi->PrimaryVidMapped = TRUE;
+    }
+
+    LEAVE_PROC("SMI_MapMem");
+    return TRUE;
 }
 
 /* UnMapMem - contains half of pre-4.0 EnterLeave function.  The EnterLeave
@@ -2122,27 +1905,25 @@ SMI_MapMem(ScrnInfoPtr pScrn)
 static void
 SMI_UnmapMem(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_UnmapMem");
+    ENTER_PROC("SMI_UnmapMem");
 
-	/* Unmap VGA mem if mapped. */
-	if (pSmi->PrimaryVidMapped)
-	{
-		vgaHWUnmapMem(pScrn);
-		pSmi->PrimaryVidMapped = FALSE;
-	}
+    /* Unmap VGA mem if mapped. */
+    if (pSmi->PrimaryVidMapped) {
+	vgaHWUnmapMem(pScrn);
+	pSmi->PrimaryVidMapped = FALSE;
+    }
 
-	SMI_DisableMmio(pScrn);
+    SMI_DisableMmio(pScrn);
 
-	xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pSmi->MapBase, pSmi->MapSize);
-	if (pSmi->FBBase != NULL)
-	{
-		xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pSmi->FBBase,
-				pSmi->videoRAMBytes);
-	}
+    xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pSmi->MapBase, pSmi->MapSize);
+    if (pSmi->FBBase != NULL) {
+	xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pSmi->FBBase,
+			pSmi->videoRAMBytes);
+    }
 
-	LEAVE_PROC("SMI_UnmapMem");
+    LEAVE_PROC("SMI_UnmapMem");
 }
 
 /* This gets called at the start of each server generation. */
@@ -2150,221 +1931,201 @@ SMI_UnmapMem(ScrnInfoPtr pScrn)
 static Bool
 SMI_ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 {
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	EntityInfoPtr pEnt;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    EntityInfoPtr pEnt;
 	
-	ENTER_PROC("SMI_ScreenInit");
+    ENTER_PROC("SMI_ScreenInit");
 
-	/* Map MMIO regs and framebuffer */
-	if (!SMI_MapMem(pScrn))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
-	}
+    /* Map MMIO regs and framebuffer */
+    if (!SMI_MapMem(pScrn)) {
+	LEAVE_PROC("SMI_ScreenInit");
+	return FALSE;
+    }
 
-	pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+    pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 	
-	if (!pSmi->pInt10) {
-	    pSmi->pInt10 = xf86InitInt10(pEnt->index);
-	}
+    if (!pSmi->pInt10) {
+	pSmi->pInt10 = xf86InitInt10(pEnt->index);
+    }
 
-	/* Save the chip/graphics state */
-	SMI_Save(pScrn);
+    /* Save the chip/graphics state */
+    SMI_Save(pScrn);
 	
-	/* Zero the frame buffer, #258 */
-	memset(pSmi->FBBase, 0, pSmi->videoRAMBytes);
-
-	/* Initialize the first mode */
-	if (!SMI_ModeInit(pScrn, pScrn->currentMode))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
-	}
-
-	/*
-	 * The next step is to setup the screen's visuals, and initialise the
-	 * framebuffer code.  In cases where the framebuffer's default choises for
-	 * things like visual layouts and bits per RGB are OK, this may be as simple
-	 * as calling the framebuffer's ScreenInit() function.  If not, the visuals
-	 * will need to be setup before calling a fb ScreenInit() function and fixed
-	 * up after.
-	 */
+    /* Zero the frame buffer, #258 */
+    memset(pSmi->FBBase, 0, pSmi->videoRAMBytes);
 
-	/*
-	 * Reset the visual list.
-	 */
-	miClearVisualTypes();
-
-	/* Setup the visuals we support. */
-
-	if (!miSetVisualTypes(pScrn->depth,
-			miGetDefaultVisualMask(pScrn->depth), pScrn->rgbBits,
-			pScrn->defaultVisual))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
-	}
-	if (!miSetPixmapDepths ()) return FALSE;
-
-	if (!SMI_InternalScreenInit(scrnIndex, pScreen))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
-	}
-
-	xf86SetBlackWhitePixels(pScreen);
+    /* Initialize the first mode */
+    if (!SMI_ModeInit(pScrn, pScrn->currentMode)) {
+	LEAVE_PROC("SMI_ScreenInit");
+	return FALSE;
+    }
+
+    /*
+     * The next step is to setup the screen's visuals, and initialise the
+     * framebuffer code.  In cases where the framebuffer's default choises for
+     * things like visual layouts and bits per RGB are OK, this may be as simple
+     * as calling the framebuffer's ScreenInit() function.  If not, the visuals
+     * will need to be setup before calling a fb ScreenInit() function and fixed
+     * up after.
+     */
+
+    /*
+     * Reset the visual list.
+     */
+    miClearVisualTypes();
+
+    /* Setup the visuals we support. */
+
+    if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth),
+			  pScrn->rgbBits, pScrn->defaultVisual)) {
+	LEAVE_PROC("SMI_ScreenInit");
+	return FALSE;
+    }
+    if (!miSetPixmapDepths ()) return FALSE;
 
-	if (pScrn->bitsPerPixel > 8)
-	{
-		VisualPtr visual;
-		/* Fixup RGB ordering */
-		visual = pScreen->visuals + pScreen->numVisuals;
-		while (--visual >= pScreen->visuals)
-		{
-			if ((visual->class | DynamicClass) == DirectColor)
-			{
-				visual->offsetRed   = pScrn->offset.red;
-				visual->offsetGreen = pScrn->offset.green;
-				visual->offsetBlue  = pScrn->offset.blue;
-				visual->redMask     = pScrn->mask.red;
-				visual->greenMask   = pScrn->mask.green;
-				visual->blueMask    = pScrn->mask.blue;
-			}
-		}
+    if (!SMI_InternalScreenInit(scrnIndex, pScreen)) {
+	LEAVE_PROC("SMI_ScreenInit");
+	return FALSE;
+    }
+
+    xf86SetBlackWhitePixels(pScreen);
+
+    if (pScrn->bitsPerPixel > 8) {
+	VisualPtr visual;
+	/* Fixup RGB ordering */
+	visual = pScreen->visuals + pScreen->numVisuals;
+	while (--visual >= pScreen->visuals) {
+	    if ((visual->class | DynamicClass) == DirectColor) {
+		visual->offsetRed   = pScrn->offset.red;
+		visual->offsetGreen = pScrn->offset.green;
+		visual->offsetBlue  = pScrn->offset.blue;
+		visual->redMask     = pScrn->mask.red;
+		visual->greenMask   = pScrn->mask.green;
+		visual->blueMask    = pScrn->mask.blue;
+	    }
 	}
+    }
 
-	/* must be after RGB ordering fixed */
-	fbPictureInit(pScreen, 0, 0);
+    /* must be after RGB ordering fixed */
+    fbPictureInit(pScreen, 0, 0);
  
-	/* CZ 18.06.2001: moved here from smi_accel.c to have offscreen
-	   framebuffer in NoAccel mode */
-	{
-	    int numLines, maxLines;
-	    BoxRec AvailFBArea;
+    /* CZ 18.06.2001: moved here from smi_accel.c to have offscreen
+       framebuffer in NoAccel mode */
+    {
+	int numLines, maxLines;
+	BoxRec AvailFBArea;
  
-	    maxLines = pSmi->FBReserved / (pSmi->width * pSmi->Bpp);
-	    if (pSmi->rotate) {
-		numLines = maxLines;
-	    } else {
-		/* CZ 3.11.2001: What does the following code? see also smi_video.c aaa line 1226 */
+	maxLines = pSmi->FBReserved / (pSmi->width * pSmi->Bpp);
+	if (pSmi->rotate) {
+	    numLines = maxLines;
+	} else {
+	    /* CZ 3.11.2001: What does the following code? see also smi_video.c aaa line 1226 */
 /*#if SMI_USE_VIDEO */
 #if 0
-		numLines = ((pSmi->FBReserved - pSmi->width * pSmi->Bpp
-			     * pSmi->height) * 25 / 100 + pSmi->width
-			    * pSmi->Bpp - 1) / (pSmi->width * pSmi->Bpp);
-		numLines += pSmi->height;
+	    numLines = ((pSmi->FBReserved - pSmi->width * pSmi->Bpp
+			* pSmi->height) * 25 / 100 + pSmi->width
+			* pSmi->Bpp - 1) / (pSmi->width * pSmi->Bpp);
+	    numLines += pSmi->height;
 #else
-		numLines = maxLines;
+	    numLines = maxLines;
 #endif
-	    }
+	}
  
-	    AvailFBArea.x1 = 0;
-	    AvailFBArea.y1 = 0;
-	    AvailFBArea.x2 = pSmi->width;
-	    AvailFBArea.y2 = numLines;
-	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-		       "FrameBuffer Box: %d,%d - %d,%d\n",
-		       AvailFBArea.x1, AvailFBArea.y1, AvailFBArea.x2,
-		       AvailFBArea.y2);
-	    xf86InitFBManager(pScreen, &AvailFBArea);
-	}
-	/* end CZ */
+	AvailFBArea.x1 = 0;
+	AvailFBArea.y1 = 0;
+	AvailFBArea.x2 = pSmi->width;
+	AvailFBArea.y2 = numLines;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		   "FrameBuffer Box: %d,%d - %d,%d\n",
+		   AvailFBArea.x1, AvailFBArea.y1, AvailFBArea.x2,
+		   AvailFBArea.y2);
+	xf86InitFBManager(pScreen, &AvailFBArea);
+    }
+    /* end CZ */
 	
 	
-	/* Initialize acceleration layer */
-	if (!pSmi->NoAccel) {
-		if (!SMI_AccelInit(pScreen)) {
-		    LEAVE_PROC("SMI_ScreenInit");
-		    return(FALSE);
-		}
+    /* Initialize acceleration layer */
+    if (!pSmi->NoAccel) {
+	if (!SMI_AccelInit(pScreen)) {
+	    LEAVE_PROC("SMI_ScreenInit");
+	    return FALSE;
 	}
+    }
 	
-	miInitializeBackingStore(pScreen);
+    miInitializeBackingStore(pScreen);
 	
-	/* hardware cursor needs to wrap this layer */
-  	SMI_DGAInit(pScreen);
+    /* hardware cursor needs to wrap this layer */
+    SMI_DGAInit(pScreen);
 	
-	/* Initialise cursor functions */
-	miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+    /* Initialise cursor functions */
+    miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
 
-	/* Initialize HW cursor layer.  Must follow software cursor
-	 * initialization.
-	 */
-	if (pSmi->hwcursor)
-	{
-		if (!SMI_HWCursorInit(pScreen))
-		{
-			xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Hardware cursor "
-					"initialization failed\n");
-		}
+    /* Initialize HW cursor layer.  Must follow software cursor
+     * initialization.
+     */
+    if (pSmi->hwcursor) {
+	if (!SMI_HWCursorInit(pScreen)) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Hardware cursor "
+		       "initialization failed\n");
 	}
+    }
 
-	if (pSmi->shadowFB)
-	{
-		RefreshAreaFuncPtr refreshArea;
+    if (pSmi->shadowFB) {
+	RefreshAreaFuncPtr refreshArea;
 
-		if (pSmi->Chipset == SMI_COUGAR3DR)
-		{
-			refreshArea = SMI_RefreshArea730;
-		}
-		else
-		{
-			refreshArea = SMI_RefreshArea;
-		}
-
-		if (pSmi->rotate)
-		{
-			if (pSmi->PointerMoved == NULL)
-			{
-				pSmi->PointerMoved  = pScrn->PointerMoved;
-				pScrn->PointerMoved = SMI_PointerMoved;
-			}
-		}
-
-		ShadowFBInit(pScreen, refreshArea);
-	}
-
-	/* Initialise default colormap */
-	if (!miCreateDefColormap(pScreen))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
+	if (pSmi->Chipset == SMI_COUGAR3DR) {
+	    refreshArea = SMI_RefreshArea730;
+	} else {
+	    refreshArea = SMI_RefreshArea;
 	}
 
-	/* Initialize colormap layer.  Must follow initialization of the default
-	 * colormap.  And SetGamma call, else it will load palette with solid white.
-	 */
-    /* CZ 2.11.2001: CMAP_PALETTED_TRUECOLOR for gamma correction */
-    if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits, SMI_LoadPalette, NULL,
-            CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
-	{
-		LEAVE_PROC("SMI_ScreenInit");
-		return(FALSE);
+	if (pSmi->rotate) {
+	    if (pSmi->PointerMoved == NULL) {
+		pSmi->PointerMoved  = pScrn->PointerMoved;
+		pScrn->PointerMoved = SMI_PointerMoved;
+	    }
 	}
 
-	pScreen->SaveScreen = SMI_SaveScreen;
-	pSmi->CloseScreen = pScreen->CloseScreen;
-	pScreen->CloseScreen = SMI_CloseScreen;
-
-	if (!xf86DPMSInit(pScreen, SMI_DisplayPowerManagementSet, 0))
-	{
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "DPMS initialization failed!\n");
-	}
+	ShadowFBInit(pScreen, refreshArea);
+    }
 
-	if (!pSmi->Dualhead)
-  	    SMI_InitVideo(pScreen);
-	else 
-	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No overlay in dualhead mode\n");
+    /* Initialise default colormap */
+    if (!miCreateDefColormap(pScreen)) {
+	LEAVE_PROC("SMI_ScreenInit");
+	return FALSE;
+    }
 
-	/* Report any unused options (only for the first generation) */
-	if (serverGeneration == 1)
-	{
-		xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
-	}
-	
+    /* Initialize colormap layer.  Must follow initialization of the default
+     * colormap.  And SetGamma call, else it will load palette with solid white.
+     */
+    /* CZ 2.11.2001: CMAP_PALETTED_TRUECOLOR for gamma correction */
+    if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits, SMI_LoadPalette, NULL,
+            CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR)) {
 	LEAVE_PROC("SMI_ScreenInit");
-	return(TRUE);
+	return FALSE;
+    }
+
+    pScreen->SaveScreen = SMI_SaveScreen;
+    pSmi->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = SMI_CloseScreen;
+
+    if (!xf86DPMSInit(pScreen, SMI_DisplayPowerManagementSet, 0)) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "DPMS initialization failed!\n");
+    }
+
+    if (!pSmi->Dualhead)
+  	SMI_InitVideo(pScreen);
+    else 
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "No overlay in dualhead mode\n");
+
+    /* Report any unused options (only for the first generation) */
+    if (serverGeneration == 1) {
+	xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+    }
+	
+    LEAVE_PROC("SMI_ScreenInit");
+    return TRUE;
 }
 
 /* Common init routines needed in EnterVT and ScreenInit */
@@ -2372,649 +2133,559 @@ SMI_ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 static int
 SMI_InternalScreenInit(int scrnIndex, ScreenPtr pScreen)
 {
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int width, height, displayWidth;
-	int bytesPerPixel = pScrn->bitsPerPixel / 8;
-	int xDpi, yDpi;
-	int ret;
-
-	ENTER_PROC("SMI_InternalScreenInit");
-
-	if (pSmi->rotate)
-	{
-		width        = pScrn->virtualY;
-		height       = pScrn->virtualX;
-		xDpi         = pScrn->yDpi;
-		yDpi         = pScrn->xDpi;
-		displayWidth = ((width * bytesPerPixel + 15) & ~15) / bytesPerPixel;
-	}
-	else
-	{
-		width        = pScrn->virtualX;
-		height       = pScrn->virtualY;
-		xDpi		 = pScrn->xDpi;
-		yDpi		 = pScrn->yDpi;
-		displayWidth = pScrn->displayWidth;
-	}
-
-	if (pSmi->shadowFB)
-	{
-		pSmi->ShadowWidth      = width;
-		pSmi->ShadowHeight     = height;
-		pSmi->ShadowWidthBytes = (width * bytesPerPixel + 15) & ~15;
-		if (bytesPerPixel == 3)
-		{
-			pSmi->ShadowPitch = ((height * 3) << 16)
-							  | pSmi->ShadowWidthBytes;
-		}
-		else
-		{
-			pSmi->ShadowPitch = (height << 16)
-							  | (pSmi->ShadowWidthBytes / bytesPerPixel);
-		}
-
-		pSmi->saveBufferSize = pSmi->ShadowWidthBytes * pSmi->ShadowHeight;
-		pSmi->FBReserved -= pSmi->saveBufferSize;
-		pSmi->FBReserved &= ~0x15;
-		WRITE_VPR(pSmi, 0x0C, (pSmi->FBOffset = pSmi->FBReserved) >> 3);
-		if(pSmi->Chipset == SMI_COUGAR3DR)
-		{
-			WRITE_FPR(pSmi, FPR0C, (pSmi->FBOffset = pSmi->FBReserved) >> 3);
-		}
-		pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-				"Shadow: width=%d height=%d "
-				"offset=0x%08lX pitch=0x%08X\n",
-				pSmi->ShadowWidth, pSmi->ShadowHeight,
-				(unsigned long)pSmi->FBOffset,
-				pSmi->ShadowPitch);
-	}
-	else
-	{
-		pSmi->FBOffset = 0;
-		pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
-	}
-
-	/*
-	 * Call the framebuffer layer's ScreenInit function, and fill in other
-	 * pScreen fields.
-	 */
-
-	DEBUG((VERBLEV, "\tInitializing FB @ 0x%08X for %dx%d (%d)\n",
-			pSmi->FBBase, width, height, displayWidth));
-	switch (pScrn->bitsPerPixel)
-	{
-	case 8:
-	case 16:
-	case 24:
-	  ret = fbScreenInit(pScreen, pSmi->FBBase, width, height, xDpi,
-			     yDpi, displayWidth,pScrn->bitsPerPixel);
-	  break;
-	default:
-	  xf86DrvMsg(scrnIndex, X_ERROR, "Internal error: invalid bpp (%d) "
-		     "in SMI_InternalScreenInit\n", pScrn->bitsPerPixel);
-	  LEAVE_PROC("SMI_InternalScreenInit");
-	  return(FALSE);
-	}
-	
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int width, height, displayWidth;
+    int bytesPerPixel = pScrn->bitsPerPixel / 8;
+    int xDpi, yDpi;
+    int ret;
+
+    ENTER_PROC("SMI_InternalScreenInit");
+
+    if (pSmi->rotate) {
+	width        = pScrn->virtualY;
+	height       = pScrn->virtualX;
+	xDpi         = pScrn->yDpi;
+	yDpi         = pScrn->xDpi;
+	displayWidth = ((width * bytesPerPixel + 15) & ~15) / bytesPerPixel;
+    } else {
+	width        = pScrn->virtualX;
+	height       = pScrn->virtualY;
+	xDpi		 = pScrn->xDpi;
+	yDpi		 = pScrn->yDpi;
+	displayWidth = pScrn->displayWidth;
+    }
+
+    if (pSmi->shadowFB) {
+	pSmi->ShadowWidth      = width;
+	pSmi->ShadowHeight     = height;
+	pSmi->ShadowWidthBytes = (width * bytesPerPixel + 15) & ~15;
+	if (bytesPerPixel == 3) {
+	    pSmi->ShadowPitch = ((height * 3) << 16)
+			      | pSmi->ShadowWidthBytes;
+	} else {
+	    pSmi->ShadowPitch = (height << 16)
+			      | (pSmi->ShadowWidthBytes / bytesPerPixel);
+	}
+
+	pSmi->saveBufferSize = pSmi->ShadowWidthBytes * pSmi->ShadowHeight;
+	pSmi->FBReserved -= pSmi->saveBufferSize;
+	pSmi->FBReserved &= ~0x15;
+	WRITE_VPR(pSmi, 0x0C, (pSmi->FBOffset = pSmi->FBReserved) >> 3);
+	if (pSmi->Chipset == SMI_COUGAR3DR) {
+	    WRITE_FPR(pSmi, FPR0C, (pSmi->FBOffset = pSmi->FBReserved) >> 3);
+	}
+	pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		   "Shadow: width=%d height=%d "
+		   "offset=0x%08lX pitch=0x%08X\n",
+		   pSmi->ShadowWidth, pSmi->ShadowHeight,
+		   (unsigned long)pSmi->FBOffset,
+		   pSmi->ShadowPitch);
+    } else {
+	pSmi->FBOffset = 0;
+	pScrn->fbOffset = pSmi->FBOffset + pSmi->fbMapOffset;
+    }
+
+    /*
+     * Call the framebuffer layer's ScreenInit function, and fill in other
+     * pScreen fields.
+     */
+
+    DEBUG((VERBLEV, "\tInitializing FB @ 0x%08X for %dx%d (%d)\n",
+	   pSmi->FBBase, width, height, displayWidth));
+    switch (pScrn->bitsPerPixel) {
+    case 8:
+    case 16:
+    case 24:
+	ret = fbScreenInit(pScreen, pSmi->FBBase, width, height, xDpi,
+			   yDpi, displayWidth,pScrn->bitsPerPixel);
+	break;
+    default:
+	xf86DrvMsg(scrnIndex, X_ERROR, "Internal error: invalid bpp (%d) "
+		   "in SMI_InternalScreenInit\n", pScrn->bitsPerPixel);
 	LEAVE_PROC("SMI_InternalScreenInit");
-	return(ret);
+	return FALSE;
+    }
+	
+    LEAVE_PROC("SMI_InternalScreenInit");
+    return ret;
 }
 
 /* Checks if a mode is suitable for the selected configuration. */
 static ModeStatus
 SMI_ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	float refresh;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    float refresh;
 
-	ENTER_PROC("SMI_ValidMode");
-	refresh = (mode->VRefresh > 0) ? mode->VRefresh 
-	  : mode->Clock * 1000.0 / mode->VTotal / mode->HTotal;
-	xf86DrvMsg(scrnIndex, X_INFO, "Mode: %dx%d %d-bpp, %fHz\n", mode->HDisplay,
-			mode->VDisplay, pScrn->bitsPerPixel, refresh);
+    ENTER_PROC("SMI_ValidMode");
+    refresh = (mode->VRefresh > 0) ? mode->VRefresh 
+	    : mode->Clock * 1000.0 / mode->VTotal / mode->HTotal;
+    xf86DrvMsg(scrnIndex, X_INFO, "Mode: %dx%d %d-bpp, %fHz\n", mode->HDisplay,
+	       mode->VDisplay, pScrn->bitsPerPixel, refresh);
 
-	if (pSmi->shadowFB)
-	{
-		int mem;
+    if (pSmi->shadowFB) {
+	int mem;
 
-		if (pScrn->bitsPerPixel == 24)
-		{
-			LEAVE_PROC("SMI_ValidMode");
-			return(MODE_BAD);
-		}
+	if (pScrn->bitsPerPixel == 24) {
+	    LEAVE_PROC("SMI_ValidMode");
+	    return MODE_BAD;
+	}
 
-		mem  = (pScrn->virtualX * pScrn->bitsPerPixel / 8 + 15) & ~15;
-		mem *= pScrn->virtualY * 2;
+	mem  = (pScrn->virtualX * pScrn->bitsPerPixel / 8 + 15) & ~15;
+	mem *= pScrn->virtualY * 2;
 
-		if (mem > pSmi->FBReserved)	/* PDR#1074 */
-		{
-			LEAVE_PROC("SMI_ValidMode");
-			return(MODE_MEM);
-		}
+	if (mem > pSmi->FBReserved) /* PDR#1074 */ {
+	    LEAVE_PROC("SMI_ValidMode");
+	    return MODE_MEM;
 	}
+    }
 
-	if (!pSmi->useBIOS || pSmi->lcd)
-	{
+    if (!pSmi->useBIOS || pSmi->lcd) {
 #if 1 /* PDR#983 */
-		if (pSmi->zoomOnLCD)
-		{
-			if (   (mode->HDisplay > pSmi->lcdWidth)
-				|| (mode->VDisplay > pSmi->lcdHeight)
-			)
-			{
-				LEAVE_PROC("SMI_ValidMode");
-				return(MODE_PANEL);
-			}
-		}
-		else
+	if (pSmi->zoomOnLCD) {
+	    if ((mode->HDisplay > pSmi->lcdWidth) ||
+		(mode->VDisplay > pSmi->lcdHeight)) {
+		LEAVE_PROC("SMI_ValidMode");
+		return MODE_PANEL;
+	    }
+	} else
 #endif
-		{
-			if (   (mode->HDisplay != pSmi->lcdWidth)
-				|| (mode->VDisplay != pSmi->lcdHeight)
-			)
-			{
-				LEAVE_PROC("SMI_ValidMode");
-				return(MODE_PANEL);
-			}
-		}
-
+	{
+	    if ((mode->HDisplay != pSmi->lcdWidth) ||
+		(mode->VDisplay != pSmi->lcdHeight)) {
+		LEAVE_PROC("SMI_ValidMode");
+		return MODE_PANEL;
+	    }
 	}
+    }
 
 #if 1 /* PDR#944 */
-	if (pSmi->rotate)
-	{
-		if (   (mode->HDisplay != pSmi->lcdWidth)
-			|| (mode->VDisplay != pSmi->lcdHeight)
-		)
-		{
-			LEAVE_PROC("SMI_ValidMode");
-			return(MODE_PANEL);
-		}
+    if (pSmi->rotate) {
+	if ((mode->HDisplay != pSmi->lcdWidth) ||
+	    (mode->VDisplay != pSmi->lcdHeight)) {
+	    LEAVE_PROC("SMI_ValidMode");
+	    return MODE_PANEL;
 	}
+    }
 #endif
 
-	LEAVE_PROC("SMI_ValidMode");
-	return(MODE_OK);
+    LEAVE_PROC("SMI_ValidMode");
+    return MODE_OK;
 }
 
 static void
-SMI_DPRInit(ScrnInfoPtr pScrn) {
-
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int i;
-	int xyAddress[] = { 320, 400, 512, 640, 800, 1024, 1280, 1600, 2048 };
-	CARD32 DEDataFormat = 0;
-
-	/* Store values to current mode register structs */
-	SMIRegPtr new = &pSmi->ModeReg;
-
-	/* Set DPR registers */
-	pSmi->Stride = (pSmi->width * pSmi->Bpp + 15) & ~15;
-	switch (pScrn->bitsPerPixel)
-	{
-		case 8:
-			DEDataFormat = 0x00000000;
-			break;
-
-		case 16:
-			pSmi->Stride >>= 1;
-			DEDataFormat = 0x00100000;
-			break;
-
-		case 24:
-			DEDataFormat = 0x00300000;
-			break;
-
-		case 32:
-			pSmi->Stride >>= 2;
-			DEDataFormat = 0x00200000;
-			break;
-	}
-	for (i = 0; i < sizeof(xyAddress) / sizeof(xyAddress[0]); i++)
-	{
-		if (pSmi->rotate)
-		{
-			if (xyAddress[i] == pSmi->height)
-			{
-				DEDataFormat |= i << 16;
-				break;
-			}
-		}
-		else
-		{
-			if (xyAddress[i] == pSmi->width)
-			{
-				DEDataFormat |= i << 16;
-				break;
-			}
-		}
-	}
-	new->DPR10 = (pSmi->Stride << 16) | pSmi->Stride;
-	new->DPR1C = DEDataFormat;
-	new->DPR20 = 0;
-	new->DPR24 = 0xFFFFFFFF;
-	new->DPR28 = 0xFFFFFFFF;
-	new->DPR2C = 0;
-	new->DPR30 = 0;
-	new->DPR3C = (pSmi->Stride << 16) | pSmi->Stride;
-	new->DPR40 = pSmi->FBOffset;
-	new->DPR44 = pSmi->FBOffset;
-}
-
-static Bool
-SMI_ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+SMI_DPRInit(ScrnInfoPtr pScrn)
 {
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	unsigned char tmp;
-	int panelIndex, modeIndex, i;
-
-	/* Store values to current mode register structs */
-	SMIRegPtr new = &pSmi->ModeReg;
-	vgaRegPtr vganew = &hwp->ModeReg;
-	
-	ENTER_PROC("SMI_ModeInit");
-
-	if(!vgaHWInit(pScrn, mode))
-	{
-		LEAVE_PROC("SMI_ModeInit");
-		return(FALSE);
-	}
-
-	new->modeInit = TRUE;
-
-	if (pSmi->rotate)
-	{
-		pSmi->width  = pScrn->virtualY;
-		pSmi->height = pScrn->virtualX;
-	}
-	else
-	{
-		pSmi->width  = pScrn->virtualX;
-		pSmi->height = pScrn->virtualY;
-	}
-	pSmi->Bpp    = pScrn->bitsPerPixel / 8;
-
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x17);
-	tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
-	if (pSmi->pci_burst)
-	{
-		new->SR17 = tmp | 0x20;
-	}
-	else
-	{
-		new->SR17 = tmp & ~0x20;
-	}
-
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
-	new->SR18 = inb(pSmi->PIOBase + VGA_SEQ_DATA) | 0x11;
-
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
-	new->SR21 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0x03;
-
-	if (pSmi->Chipset != SMI_COUGAR3DR)
-	{
-		outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x31);
-		new->SR31 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0xC0;
-
-		outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x32);
-		new->SR32 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0x07;
-
-		if (SMI_LYNXM_SERIES(pSmi->Chipset))
-		{
-			new->SR32 |= 0x04;
-		}
-	}
-
-	new->SRA0 = new->CR33 = new->CR3A = 0x00;
-
-	if (pSmi->lcdWidth == 640)
-	{
-		panelIndex = 0;
-	}
-	else if (pSmi->lcdWidth == 800)
-	{
-		panelIndex = 1;
-	}
-	else
-	{
-		panelIndex = 2;
-	}
-
-	if (mode->HDisplay == 640)
-	{
-		modeIndex = 0;
-	}
-	else if (mode->HDisplay == 800)
-	{
-		modeIndex = 1;
-	}
-	else
-	{
-		modeIndex = 2;
-	}
-
-	if (SMI_LYNXM_SERIES(pSmi->Chipset))
-	{
-		static unsigned char PanelTable[3][14] =
-		{
-			{ 0x5F, 0x4F, 0x00, 0x52, 0x1E, 0x0B, 0xDF, 0x00, 0xE9, 0x0B, 0x2E,
-			  0x00, 0x4F, 0xDF },
-			{ 0x7F, 0x63, 0x00, 0x69, 0x19, 0x72, 0x57, 0x00, 0x58, 0x0C, 0xA2,
-			  0x20, 0x4F, 0xDF },
-			{ 0xA3, 0x7F, 0x00, 0x83, 0x14, 0x24, 0xFF, 0x00, 0x02, 0x08, 0xA7,
-			  0xE0, 0x4F, 0xDF },
-		};
-
-		for (i = 0; i < 14; i++)
-		{
-			new->CR40[i] = PanelTable[panelIndex][i];
-		}
-		new->CR90[14] = 0x03;
-		new->CR90[15] = 0x00;
-		if (mode->VDisplay < pSmi->lcdHeight)
-		{
-			new->CRA0[6] = (pSmi->lcdHeight - mode->VDisplay) / 8;
-		}
-		else
-		{
-			new->CRA0[6] = 0;
-		}
-
-		if (mode->HDisplay < pSmi->lcdWidth)
-		{
-			new->CRA0[7] = (pSmi->lcdWidth - mode->HDisplay) / 16;
-		}
-		else
-		{
-			new->CRA0[7] = 0;
-		}
-	}
-	else
-	{
-		static unsigned char PanelTable[3][3][14] =
-		{
-			{ /* 640x480 panel */
-		        { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
-		          0x2E, 0x00, 0x4F, 0xDF },
-		        { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
-		          0x2E, 0x00, 0x4F, 0xDF },
-		        { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
-		          0x2E, 0x00, 0x4F, 0xDF },
-			},
-			{ /* 800x600 panel */
-		        { 0x7F, 0x59, 0x19, 0x5E, 0x8E, 0x72, 0x1C, 0x37, 0x1D, 0x00,
-		          0xA2, 0x20, 0x4F, 0xDF },
-		        { 0x7F, 0x63, 0x00, 0x68, 0x18, 0x72, 0x58, 0x00, 0x59, 0x0C,
-		          0xE0, 0x20, 0x63, 0x57 },
-		        { 0x7F, 0x63, 0x00, 0x68, 0x18, 0x72, 0x58, 0x00, 0x59, 0x0C,
-		          0xE0, 0x20, 0x63, 0x57 },
-			},
-			{ /* 1024x768 panel */
-		        { 0xA3, 0x67, 0x0F, 0x6D, 0x1D, 0x24, 0x70, 0x95, 0x72, 0x07,
-		          0xA3, 0x20, 0x4F, 0xDF },
-		        { 0xA3, 0x71, 0x19, 0x77, 0x07, 0x24, 0xAC, 0xD1, 0xAE, 0x03,
-		          0xE1, 0x20, 0x63, 0x57 },
-		        { 0xA3, 0x7F, 0x00, 0x85, 0x15, 0x24, 0xFF, 0x00, 0x01, 0x07,
-		          0xE5, 0x20, 0x7F, 0xFF },
-			},
-		};
-
-		for (i = 0; i < 14; i++)
-		{
-			new->CR40[i] = PanelTable[panelIndex][modeIndex][i];
-		}
-	}
-
-	/* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
-	new->CCR66 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
-	if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)){
-	    switch (pScrn->bitsPerPixel) {
-	    case 8:
-		new->CCR66 = (new->CCR66 & 0xF3) | 0x00; /* 6 bits-RAM */
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int i;
+    int xyAddress[] = { 320, 400, 512, 640, 800, 1024, 1280, 1600, 2048 };
+    CARD32 DEDataFormat = 0;
+
+    /* Store values to current mode register structs */
+    SMIRegPtr new = &pSmi->ModeReg;
+
+    /* Set DPR registers */
+    pSmi->Stride = (pSmi->width * pSmi->Bpp + 15) & ~15;
+    switch (pScrn->bitsPerPixel) {
+    case 8:
+	DEDataFormat = 0x00000000;
+	break;
+    case 16:
+	pSmi->Stride >>= 1;
+	DEDataFormat = 0x00100000;
+	break;
+    case 24:
+	DEDataFormat = 0x00300000;
+	break;
+    case 32:
+	pSmi->Stride >>= 2;
+	DEDataFormat = 0x00200000;
+	break;
+    }
+
+    for (i = 0; i < sizeof(xyAddress) / sizeof(xyAddress[0]); i++) {
+	if (pSmi->rotate) {
+	    if (xyAddress[i] == pSmi->height) {
+		DEDataFormat |= i << 16;
 		break;
-	    case 16:
-		new->CCR66 = (new->CCR66 & 0xF3) | 0x00; /* 6 bits-RAM */
-		/* no Gamma correction in 16 Bit mode (s. Release.txt 1.3.1) */
-		break;
-	    case 24:
-	    case 32:
-		new->CCR66 = (new->CCR66 & 0xF3) | 0x04; /* Gamma correct ON */
+	    }
+	} else {
+	    if (xyAddress[i] == pSmi->width) {
+		DEDataFormat |= i << 16;
 		break;
-	    default:
-		LEAVE_PROC("SMI_ModeInit");
-		return(FALSE);
 	    }
 	}
+    }
 
-	if (pSmi->Chipset != SMI_COUGAR3DR)
-	{
-		outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x30);
-		if (inb(pSmi->PIOBase + VGA_SEQ_DATA) & 0x01)
-		{
-			new->SR21 = 0x00;
-		}
-	}
-
-	if (pSmi->MCLK > 0)
-	{
-		SMI_CommonCalcClock(pScrn->scrnIndex, pSmi->MCLK,
-				    1, 1, 31, 0, 2,
-                                    pScrn->clockRanges->minClock,
-                                    pScrn->clockRanges->maxClock,
-                                    &new->SR6A, &new->SR6B);
-	}
-	else
-	{
-		new->SR6B = 0xFF;
-	}
-
-	if ((mode->HDisplay == 640) && SMI_LYNXM_SERIES(pSmi->Chipset))
-	{
-		vganew->MiscOutReg &= ~0x0C;
-	}
-	else
-	{
-		vganew->MiscOutReg |= 0x0C;
-	}
-	vganew->MiscOutReg |= 0xE0;
-	if (mode->HDisplay == 800)
-	{
-		vganew->MiscOutReg &= ~0xC0;
-	}
-	if ((mode->HDisplay == 1024) && SMI_LYNXM_SERIES(pSmi->Chipset))
-	{
-		vganew->MiscOutReg &= ~0xC0;
-	}
+    new->DPR10 = (pSmi->Stride << 16) | pSmi->Stride;
+    new->DPR1C = DEDataFormat;
+    new->DPR20 = 0;
+    new->DPR24 = 0xFFFFFFFF;
+    new->DPR28 = 0xFFFFFFFF;
+    new->DPR2C = 0;
+    new->DPR30 = 0;
+    new->DPR3C = (pSmi->Stride << 16) | pSmi->Stride;
+    new->DPR40 = pSmi->FBOffset >> 3;
+    new->DPR44 = pSmi->FBOffset >> 3;
 
-	/* dualhead */
-	if (pSmi->Dualhead) {
-
-	    /* PLL controls */
-	    /* set CRT to vclk */
-	    new->SR68 = 0x54;
-	    /* set LCD to vclk2 */
-	    new->SR69 = 0x04;
+}
 
-	    if (pSmi->lcdWidth == 640)
-	    {
-	        /* vclk */
-	        new->SR6C = 0x07;
-	        new->SR6D = 0x04;
+static Bool
+SMI_ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    unsigned char tmp;
+    int panelIndex, modeIndex, i;
+
+    /* Store values to current mode register structs */
+    SMIRegPtr new = &pSmi->ModeReg;
+    vgaRegPtr vganew = &hwp->ModeReg;
+	
+    ENTER_PROC("SMI_ModeInit");
 
-	        /* vclk2 */
-	        new->SR6E = 0x07;
-	        new->SR6F = 0x04;
-	    }
-	    else if (pSmi->lcdWidth == 800)
+    if (!vgaHWInit(pScrn, mode)) {
+	LEAVE_PROC("SMI_ModeInit");
+	return FALSE;
+    }
+
+    new->modeInit = TRUE;
+
+    if (pSmi->rotate) {
+	pSmi->width  = pScrn->virtualY;
+	pSmi->height = pScrn->virtualX;
+    } else {
+	pSmi->width  = pScrn->virtualX;
+	pSmi->height = pScrn->virtualY;
+    }
+    pSmi->Bpp    = pScrn->bitsPerPixel / 8;
+
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x17);
+    tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
+    if (pSmi->pci_burst) {
+	new->SR17 = tmp | 0x20;
+    } else {
+	new->SR17 = tmp & ~0x20;
+    }
+
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
+    new->SR18 = inb(pSmi->PIOBase + VGA_SEQ_DATA) | 0x11;
+
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
+    new->SR21 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0x03;
+
+    if (pSmi->Chipset != SMI_COUGAR3DR) {
+	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x31);
+	new->SR31 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0xC0;
+
+	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x32);
+	new->SR32 = inb(pSmi->PIOBase + VGA_SEQ_DATA) & ~0x07;
+
+	if (SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	    new->SR32 |= 0x04;
+	}
+    }
+
+    new->SRA0 = new->CR33 = new->CR3A = 0x00;
+
+    if (pSmi->lcdWidth == 640) {
+	panelIndex = 0;
+    } else if (pSmi->lcdWidth == 800) {
+	panelIndex = 1;
+    } else {
+	panelIndex = 2;
+    }
+
+    if (mode->HDisplay == 640) {
+	modeIndex = 0;
+    } else if (mode->HDisplay == 800) {
+	modeIndex = 1;
+    } else {
+	modeIndex = 2;
+    }
+
+    if (SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	static unsigned char PanelTable[3][14] =
 	    {
-	        /* vclk */
-	        new->SR6C = 0x0B;
-	        new->SR6D = 0x82;
-
-	        /* vclk2 */
-	        new->SR6E = 0x0B;
-	        new->SR6F = 0x82;
-	    }
-	    else
+		{ 0x5F, 0x4F, 0x00, 0x52, 0x1E, 0x0B, 0xDF, 0x00, 0xE9, 0x0B, 0x2E,
+		  0x00, 0x4F, 0xDF },
+		{ 0x7F, 0x63, 0x00, 0x69, 0x19, 0x72, 0x57, 0x00, 0x58, 0x0C, 0xA2,
+		  0x20, 0x4F, 0xDF },
+		{ 0xA3, 0x7F, 0x00, 0x83, 0x14, 0x24, 0xFF, 0x00, 0x02, 0x08, 0xA7,
+		  0xE0, 0x4F, 0xDF },
+	    };
+
+	for (i = 0; i < 14; i++) {
+	    new->CR40[i] = PanelTable[panelIndex][i];
+	}
+	new->CR90[14] = 0x03;
+	new->CR90[15] = 0x00;
+	if (mode->VDisplay < pSmi->lcdHeight) {
+	    new->CRA0[6] = (pSmi->lcdHeight - mode->VDisplay) / 8;
+	} else {
+	    new->CRA0[6] = 0;
+	}
+
+	if (mode->HDisplay < pSmi->lcdWidth) {
+	    new->CRA0[7] = (pSmi->lcdWidth - mode->HDisplay) / 16;
+	} else {
+	    new->CRA0[7] = 0;
+	}
+    } else {
+	static unsigned char PanelTable[3][3][14] =
 	    {
-	        /* vclk */
-	        new->SR6C = 0x52;
-	        new->SR6D = 0x89;
-
-	        /* vclk2 */
-	        new->SR6E = 0x52;
-	        new->SR6F = 0x89;
-	    }
+		{ /* 640x480 panel */
+		    { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
+		      0x2E, 0x00, 0x4F, 0xDF },
+		    { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
+		      0x2E, 0x00, 0x4F, 0xDF },
+		    { 0x5F, 0x4F, 0x00, 0x53, 0x00, 0x0B, 0xDF, 0x00, 0xEA, 0x0C,
+		      0x2E, 0x00, 0x4F, 0xDF },
+		},
+		{ /* 800x600 panel */
+		    { 0x7F, 0x59, 0x19, 0x5E, 0x8E, 0x72, 0x1C, 0x37, 0x1D, 0x00,
+		      0xA2, 0x20, 0x4F, 0xDF },
+		    { 0x7F, 0x63, 0x00, 0x68, 0x18, 0x72, 0x58, 0x00, 0x59, 0x0C,
+		      0xE0, 0x20, 0x63, 0x57 },
+		    { 0x7F, 0x63, 0x00, 0x68, 0x18, 0x72, 0x58, 0x00, 0x59, 0x0C,
+		      0xE0, 0x20, 0x63, 0x57 },
+		},
+		{ /* 1024x768 panel */
+		    { 0xA3, 0x67, 0x0F, 0x6D, 0x1D, 0x24, 0x70, 0x95, 0x72, 0x07,
+		      0xA3, 0x20, 0x4F, 0xDF },
+		    { 0xA3, 0x71, 0x19, 0x77, 0x07, 0x24, 0xAC, 0xD1, 0xAE, 0x03,
+		      0xE1, 0x20, 0x63, 0x57 },
+		    { 0xA3, 0x7F, 0x00, 0x85, 0x15, 0x24, 0xFF, 0x00, 0x01, 0x07,
+		      0xE5, 0x20, 0x7F, 0xFF },
+		},
+	    };
+
+	for (i = 0; i < 14; i++) {
+	    new->CR40[i] = PanelTable[panelIndex][modeIndex][i];
+	}
+    }
+
+    /* CZ 2.11.2001: for gamma correction (TODO: other chipsets?) */
+    new->CCR66 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
+    if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) {
+	switch (pScrn->bitsPerPixel) {
+	case 8:
+	    new->CCR66 = (new->CCR66 & 0xF3) | 0x00; /* 6 bits-RAM */
+	    break;
+	case 16:
+	    new->CCR66 = (new->CCR66 & 0xF3) | 0x00; /* 6 bits-RAM */
+	    /* no Gamma correction in 16 Bit mode (s. Release.txt 1.3.1) */
+	    break;
+	case 24:
+	case 32:
+	    new->CCR66 = (new->CCR66 & 0xF3) | 0x04; /* Gamma correct ON */
+	    break;
+	default:
+	    LEAVE_PROC("SMI_ModeInit");
+	    return FALSE;
+	}
+    }
+
+    if (pSmi->Chipset != SMI_COUGAR3DR) {
+	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x30);
+	if (inb(pSmi->PIOBase + VGA_SEQ_DATA) & 0x01) {
+	    new->SR21 = 0x00;
+	}
+    }
+
+    if (pSmi->MCLK > 0) {
+	SMI_CommonCalcClock(pScrn->scrnIndex, pSmi->MCLK,
+			    1, 1, 31, 0, 2,
+                            pScrn->clockRanges->minClock,
+                            pScrn->clockRanges->maxClock,
+                            &new->SR6A, &new->SR6B);
+    } else {
+	new->SR6B = 0xFF;
+    }
+
+    if ((mode->HDisplay == 640) && SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	vganew->MiscOutReg &= ~0x0C;
+    } else {
+	vganew->MiscOutReg |= 0x0C;
+    }
+    vganew->MiscOutReg |= 0xE0;
+    if (mode->HDisplay == 800) {
+	vganew->MiscOutReg &= ~0xC0;
+    }
+    if ((mode->HDisplay == 1024) && SMI_LYNXM_SERIES(pSmi->Chipset)) {
+	vganew->MiscOutReg &= ~0xC0;
+    }
+
+    /* dualhead */
+    if (pSmi->Dualhead) {
+	/* PLL controls */
+	/* set CRT to vclk */
+	new->SR68 = 0x54;
+	/* set LCD to vclk2 */
+	new->SR69 = 0x04;
+
+	if (pSmi->lcdWidth == 640) {
+	    /* vclk */
+	    new->SR6C = 0x07;
+	    new->SR6D = 0x04;
+
+	    /* vclk2 */
+	    new->SR6E = 0x07;
+	    new->SR6F = 0x04;
+	} else if (pSmi->lcdWidth == 800) {
+	    /* vclk */
+	    new->SR6C = 0x0B;
+	    new->SR6D = 0x82;
+
+	    /* vclk2 */
+	    new->SR6E = 0x0B;
+	    new->SR6F = 0x82;
+	} else {
+	    /* vclk */
+	    new->SR6C = 0x52;
+	    new->SR6D = 0x89;
+
+	    /* vclk2 */
+	    new->SR6E = 0x52;
+	    new->SR6F = 0x89;
+	}
 
 	/* TFT panel uses FIFO1, DSTN panel uses FIFO1 for upper panel and 
 	 * FIFO2 for lower panel.  I don't have a DSTN panel, so it's untested.
 	 * -- AGD
 	 */
-	    CARD32 fifo1_readoffset, fifo2_readoffset, fifo_writeoffset;
-
-	    /* setting SR21 bit 2 disables ZV circuitry, 
-	     * if ZV is needed, SR21 = 0x20
-	     */
-	    /* enable DAC, PLL, etc. */
-	    new->SR21 = 0x24;
-
-	    /* clear DPMS state */
-	    new->SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22) & ~0x30;
+	CARD32 fifo1_readoffset, fifo2_readoffset, fifo_writeoffset;
 
-	    /* enable virtual refresh and LCD and CRT outputs */
-	    if (pScrn->bitsPerPixel > 8)
-		new->SR31 = /*0xCB*/ 0xC3; /* 16 bpp */
-	    else
-		new->SR31 = /*0x8B*/ 0x83; /* 8 bpp */
-
-	    /* FIFO1 Read Offset */
-	    fifo1_readoffset = pSmi->lcdWidth / 2;
-	    fifo2_readoffset = pSmi->lcdWidth / 2;
-	    new->SR44 = fifo1_readoffset & 0x000000FF;
-	    /* FIFO2 Read Offset */
-	    new->SR4B = fifo2_readoffset & 0x000000FF;
-	    /* FIFO1/2 Read Offset overflow */
-	    new->SR4C = (((fifo1_readoffset & 0x00000300) >> 8) << 2) |
-		        (((fifo2_readoffset & 0x00000300) >> 8) << 6);
-
-	    /* FIFO Write Offset */
-	    fifo_writeoffset = pSmi->lcdWidth / 4;
-	    new->SR48 = fifo_writeoffset & 0x000000FF;
-	    new->SR49 = (fifo_writeoffset & 0x00000300) >> 8;
-
-	    /* set FIFO levels */
-	    new->SR4A = 0x41;
-
-	    /* something related to tv... */
-	    new->CR33 |= 0x07;
-
-	}
+	/* setting SR21 bit 2 disables ZV circuitry, 
+	 * if ZV is needed, SR21 = 0x20
+	 */
+	/* enable DAC, PLL, etc. */
+	new->SR21 = 0x24;
 
-	/* init graphics engine regs */
-	SMI_DPRInit(pScrn);
+	/* clear DPMS state */
+	new->SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22) & ~0x30;
 
-	/* Set VPR registers (and FPR registers for SM731) */
-	switch (pScrn->bitsPerPixel)
-	{
-		case 8:
-			new->VPR00 = 0x00000000;
-			new->FPR00_= 0x00080000;
-			break;
-
-		case 16:
-			new->VPR00 = 0x00020000;
-			new->FPR00_= 0x000A0000;
-			break;
-
-		case 24:
-			new->VPR00 = 0x00040000;
-			new->FPR00_= 0x000C0000;
-			break;
-
-		case 32:
-			new->VPR00 = 0x00030000;
-			new->FPR00_= 0x000B0000;
-			break;
-	}
-	new->VPR0C = pSmi->FBOffset >> 3;
-	if (pSmi->rotate)
-	{
-		new->VPR10 = (((( pSmi->height * pSmi->Bpp) >> 3)
-				+ 2) << 16) | ((pSmi->height * pSmi->Bpp) >> 3);
-	}
+	/* enable virtual refresh and LCD and CRT outputs */
+	if (pScrn->bitsPerPixel > 8)
+	    new->SR31 = /*0xCB*/ 0xC3; /* 16 bpp */
 	else
-	{
-		new->VPR10 = ((((pSmi->width * pSmi->Bpp) >> 3)
-				+ 2) << 16) | ((pSmi->width * pSmi->Bpp) >> 3);
-	}
-
-	new->FPR0C_ = new->VPR0C;
-	new->FPR10_ = new->VPR10;
-
-	/* Set CPR registers */
-	new->CPR00 = 0x00000000;
-
-	pScrn->vtSema = TRUE;
-
-	/* Find the INT 10 mode number */
-	{
-		static struct
-		{
-			int x, y, bpp;
-			CARD16 mode;
-
-		} modeTable[] =
-		{
-			{  640,  480,  8, 0x50 },
-			{  640,  480, 16, 0x52 },
-			{  640,  480, 24, 0x53 },
-			{  640,  480, 32, 0x54 },
-			{  800,  480,  8, 0x4A },
-			{  800,  480, 16, 0x4C },
-			{  800,  480, 24, 0x4D },
-			{  800,  600,  8, 0x55 },
-			{  800,  600, 16, 0x57 },
-			{  800,  600, 24, 0x58 },
-			{  800,  600, 32, 0x59 },
-			{ 1024,  768,  8, 0x60 },
-			{ 1024,  768, 16, 0x62 },
-			{ 1024,  768, 24, 0x63 },
-			{ 1024,  768, 32, 0x64 },
-			{ 1280, 1024,  8, 0x65 },
-			{ 1280, 1024, 16, 0x67 },
-			{ 1280, 1024, 24, 0x68 },
-			{ 1280, 1024, 32, 0x69 },
-		};
-
-		new->mode = 0;
-		for (i = 0; i < sizeof(modeTable) / sizeof(modeTable[0]); i++)
-		{
-			if (   (modeTable[i].x == mode->HDisplay)
-				&& (modeTable[i].y == mode->VDisplay)
-				&& (modeTable[i].bpp == pScrn->bitsPerPixel)
-			)
-			{
-				new->mode = modeTable[i].mode;
-				break;
-			}
-		}
+	    new->SR31 = /*0x8B*/ 0x83; /* 8 bpp */
+
+	/* FIFO1 Read Offset */
+	fifo1_readoffset = pSmi->lcdWidth / 2;
+	fifo2_readoffset = pSmi->lcdWidth / 2;
+	new->SR44 = fifo1_readoffset & 0x000000FF;
+	/* FIFO2 Read Offset */
+	new->SR4B = fifo2_readoffset & 0x000000FF;
+	/* FIFO1/2 Read Offset overflow */
+	new->SR4C = (((fifo1_readoffset & 0x00000300) >> 8) << 2) |
+		    (((fifo2_readoffset & 0x00000300) >> 8) << 6);
+
+	/* FIFO Write Offset */
+	fifo_writeoffset = pSmi->lcdWidth / 4;
+	new->SR48 = fifo_writeoffset & 0x000000FF;
+	new->SR49 = (fifo_writeoffset & 0x00000300) >> 8;
+
+	/* set FIFO levels */
+	new->SR4A = 0x41;
+
+	/* something related to tv... */
+	new->CR33 |= 0x07;
+
+    }
+
+    /* init graphics engine regs */
+    SMI_DPRInit(pScrn);
+
+    /* Set VPR registers (and FPR registers for SM731) */
+    switch (pScrn->bitsPerPixel) {
+    case 8:
+	new->VPR00 = 0x00000000;
+	new->FPR00_= 0x00080000;
+	break;
+    case 16:
+	new->VPR00 = 0x00020000;
+	new->FPR00_= 0x000A0000;
+	break;
+    case 24:
+	new->VPR00 = 0x00040000;
+	new->FPR00_= 0x000C0000;
+	break;
+    case 32:
+	new->VPR00 = 0x00030000;
+	new->FPR00_= 0x000B0000;
+	break;
+    }
+    new->VPR0C = pSmi->FBOffset >> 3;
+    if (pSmi->rotate) {
+	new->VPR10 = (((( pSmi->height * pSmi->Bpp) >> 3) + 2) << 16) |
+		     ((pSmi->height * pSmi->Bpp) >> 3);
+    } else {
+	new->VPR10 = ((((pSmi->width * pSmi->Bpp) >> 3) + 2) << 16) |
+		     ((pSmi->width * pSmi->Bpp) >> 3);
+    }
+
+    new->FPR0C_ = new->VPR0C;
+    new->FPR10_ = new->VPR10;
+
+    /* Set CPR registers */
+    new->CPR00 = 0x00000000;
+
+    pScrn->vtSema = TRUE;
+
+    /* Find the INT 10 mode number */
+    {
+	static struct {
+	    int x, y, bpp;
+	    CARD16 mode;
+	} modeTable[] =
+	    {
+		{  640,  480,  8, 0x50 },
+		{  640,  480, 16, 0x52 },
+		{  640,  480, 24, 0x53 },
+		{  640,  480, 32, 0x54 },
+		{  800,  480,  8, 0x4A },
+		{  800,  480, 16, 0x4C },
+		{  800,  480, 24, 0x4D },
+		{  800,  600,  8, 0x55 },
+		{  800,  600, 16, 0x57 },
+		{  800,  600, 24, 0x58 },
+		{  800,  600, 32, 0x59 },
+		{ 1024,  768,  8, 0x60 },
+		{ 1024,  768, 16, 0x62 },
+		{ 1024,  768, 24, 0x63 },
+		{ 1024,  768, 32, 0x64 },
+		{ 1280, 1024,  8, 0x65 },
+		{ 1280, 1024, 16, 0x67 },
+		{ 1280, 1024, 24, 0x68 },
+		{ 1280, 1024, 32, 0x69 },
+	    };
+
+	new->mode = 0;
+	for (i = 0; i < sizeof(modeTable) / sizeof(modeTable[0]); i++) {
+	    if ((modeTable[i].x == mode->HDisplay) &&
+		(modeTable[i].y == mode->VDisplay) &&
+		(modeTable[i].bpp == pScrn->bitsPerPixel)) {
+		new->mode = modeTable[i].mode;
+		break;
+	    }
 	}
+    }
 
-	/* Zero the font memory */
-	memset(new->smiFont, 0, sizeof(new->smiFont));
+    /* Zero the font memory */
+    memset(new->smiFont, 0, sizeof(new->smiFont));
 
-	/* Write the mode registers to hardware */
-	SMI_WriteMode(pScrn, vganew, new);
+    /* Write the mode registers to hardware */
+    SMI_WriteMode(pScrn, vganew, new);
 
-	/* Adjust the viewport */
-	SMI_AdjustFrame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+    /* Adjust the viewport */
+    SMI_AdjustFrame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 
-	LEAVE_PROC("SMI_ModeInit");
-	return(TRUE);
+    LEAVE_PROC("SMI_ModeInit");
+    return TRUE;
 }
 
 /*
@@ -3027,363 +2698,339 @@ SMI_ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 static Bool
 SMI_CloseScreen(int scrnIndex, ScreenPtr pScreen)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	vgaRegPtr vgaSavePtr = &hwp->SavedReg;
-	SMIRegPtr SMISavePtr = &pSmi->SavedReg;
-	Bool ret;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    vgaRegPtr vgaSavePtr = &hwp->SavedReg;
+    SMIRegPtr SMISavePtr = &pSmi->SavedReg;
+    Bool ret;
 	
-	ENTER_PROC("SMI_CloseScreen");
-
-	if (pScrn->vtSema)
-	{
-		SMI_WriteMode(pScrn, vgaSavePtr, SMISavePtr);
-		vgaHWLock(hwp);
-		SMI_UnmapMem(pScrn);
-	}
-
-	if (pSmi->AccelInfoRec != NULL)
-	{
-		XAADestroyInfoRec(pSmi->AccelInfoRec);
-	}
-	if (pSmi->CursorInfoRec != NULL)
-	{
-		xf86DestroyCursorInfoRec(pSmi->CursorInfoRec);
-	}
-	if (pSmi->DGAModes != NULL)
-	{
-		xfree(pSmi->DGAModes);
-	}
-	if (pSmi->pInt10 != NULL)
-	{
-		xf86FreeInt10(pSmi->pInt10);
-		pSmi->pInt10 = NULL;
-	}
-	if (pSmi->ptrAdaptor != NULL)
-	{
-		xfree(pSmi->ptrAdaptor);
-	}
-	if (pSmi->BlockHandler != NULL)
-	{
-		pScreen->BlockHandler = pSmi->BlockHandler;
-	}
-	/* #670 */
-	if (pSmi->pSaveBuffer)
-	{
-		xfree(pSmi->pSaveBuffer);
-	}
-	/* #920 */
-	if (pSmi->paletteBuffer)
-	{
-		xfree(pSmi->paletteBuffer);
-	}
-
-	pScrn->vtSema = FALSE;
-	pScreen->CloseScreen = pSmi->CloseScreen;
-	ret = (*pScreen->CloseScreen)(scrnIndex, pScreen);
+    ENTER_PROC("SMI_CloseScreen");
 
-	LEAVE_PROC("SMI_CloseScreen");
-	return(ret);
+    if (pScrn->vtSema) {
+	SMI_WriteMode(pScrn, vgaSavePtr, SMISavePtr);
+	vgaHWLock(hwp);
+	SMI_UnmapMem(pScrn);
+    }
+
+    if (pSmi->AccelInfoRec != NULL) {
+	XAADestroyInfoRec(pSmi->AccelInfoRec);
+    }
+    if (pSmi->CursorInfoRec != NULL) {
+	xf86DestroyCursorInfoRec(pSmi->CursorInfoRec);
+    }
+    if (pSmi->DGAModes != NULL) {
+	xfree(pSmi->DGAModes);
+    }
+    if (pSmi->pInt10 != NULL) {
+	xf86FreeInt10(pSmi->pInt10);
+	pSmi->pInt10 = NULL;
+    }
+    if (pSmi->ptrAdaptor != NULL) {
+	xfree(pSmi->ptrAdaptor);
+    }
+    if (pSmi->BlockHandler != NULL) {
+	pScreen->BlockHandler = pSmi->BlockHandler;
+    }
+    /* #670 */
+    if (pSmi->pSaveBuffer) {
+	xfree(pSmi->pSaveBuffer);
+    }
+/* #920 */
+    if (pSmi->paletteBuffer) {
+	xfree(pSmi->paletteBuffer);
+    }
+
+    pScrn->vtSema = FALSE;
+    pScreen->CloseScreen = pSmi->CloseScreen;
+    ret = (*pScreen->CloseScreen)(scrnIndex, pScreen);
+
+    LEAVE_PROC("SMI_CloseScreen");
+    return ret;
 }
 
 static void
 SMI_FreeScreen(int scrnIndex, int flags)
 {
-	SMI_FreeRec(xf86Screens[scrnIndex]);
+    SMI_FreeRec(xf86Screens[scrnIndex]);
 }
 
 static Bool
 SMI_SaveScreen(ScreenPtr pScreen, int mode)
 {
-	Bool ret;
+    Bool ret;
 
-	ENTER_PROC("SMI_SaveScreen");
+    ENTER_PROC("SMI_SaveScreen");
 
-	ret = vgaHWSaveScreen(pScreen, mode);
+    ret = vgaHWSaveScreen(pScreen, mode);
 
-	LEAVE_PROC("SMI_SaveScreen");
-	return(ret);
+    LEAVE_PROC("SMI_SaveScreen");
+    return ret;
 }
 
 void
 SMI_AdjustFrame(int scrnIndex, int x, int y, int flags)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD32 Base, lcdBase;
-
-	ENTER_PROC("SMI_AdjustFrame");
-
-	if (pSmi->ShowCache && y)
-	{
-		y += pScrn->virtualY - 1;
-	}
-
-	if (pSmi->Dualhead) {
-	    lcdBase = 0;
-	    x = pSmi->lcdWidth;
-	    y = 0;
-	}
-
-	Base = pSmi->FBOffset + (x + y * pScrn->virtualX) * pSmi->Bpp;
-	if (SMI_LYNX3D_SERIES(pSmi->Chipset) || SMI_COUGAR_SERIES(pSmi->Chipset))
-	{
-		Base = (Base + 15) & ~15;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD32 Base, lcdBase;
+
+    ENTER_PROC("SMI_AdjustFrame");
+
+    if (pSmi->ShowCache && y) {
+	y += pScrn->virtualY - 1;
+    }
+
+    if (pSmi->Dualhead) {
+	lcdBase = 0;
+	x = pSmi->lcdWidth;
+	y = 0;
+    }
+
+    Base = pSmi->FBOffset + (x + y * pScrn->virtualX) * pSmi->Bpp;
+    if (SMI_LYNX3D_SERIES(pSmi->Chipset) ||
+	SMI_COUGAR_SERIES(pSmi->Chipset)) {
+	Base = (Base + 15) & ~15;
 #if 1 /* PDR#1058 */
-		while ((Base % pSmi->Bpp) > 0)
-		{
-			Base -= 16;
-		}
-#endif
+	while ((Base % pSmi->Bpp) > 0) {
+	    Base -= 16;
 	}
-	else
-	{
-		Base = (Base + 7) & ~7;
-#if 1 /* PDR#1058 */
-		while ((Base % pSmi->Bpp) > 0)
-		{
-			Base -= 8;
-		}
 #endif
+    } else {
+	Base = (Base + 7) & ~7;
+#if 1 /* PDR#1058 */
+	while ((Base % pSmi->Bpp) > 0) {
+	    Base -= 8;
 	}
+#endif
+    }
 
+    if (pSmi->Dualhead) {
 
-	if (pSmi->Dualhead) {
-
-	    /* FIFO1 read start address */
-	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x40, 
+	/* FIFO1 read start address */
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x40, 
 			 (lcdBase & 0x000000FF));
-	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x41, 
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x41, 
 			 ((lcdBase & 0x0000FF00) >> 8));
 
-	    /* FIFO2 read start address */
-	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x42, 
+	/* FIFO2 read start address */
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x42, 
 			 (lcdBase & 0x000000FF));
-	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x43, 
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x43, 
 			 ((lcdBase & 0x0000FF00) >> 8));
 
-	    /* FIFO1/2 read start address overflow */
-	    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x45, 
+	/* FIFO1/2 read start address overflow */
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x45, 
 		((lcdBase & 0x000F0000) >> 12) | (((lcdBase & 0x000F0000) >> 12) << 4));
 
-	}
+    }
 
-	WRITE_VPR(pSmi, 0x0C, Base >> 3);
-	if(pSmi->Chipset == SMI_COUGAR3DR)
-	{
-		WRITE_FPR(pSmi, FPR0C, Base >> 3);
-	}
+    WRITE_VPR(pSmi, 0x0C, Base >> 3);
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
+	WRITE_FPR(pSmi, FPR0C, Base >> 3);
+    }
 
-	LEAVE_PROC("SMI_AdjustFrame");
+    LEAVE_PROC("SMI_AdjustFrame");
 }
 
 Bool
 SMI_SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 {
-	Bool ret;
-	SMIPtr pSmi = SMIPTR(xf86Screens[scrnIndex]);
+    Bool ret;
+    SMIPtr pSmi = SMIPTR(xf86Screens[scrnIndex]);
 
-	ENTER_PROC("SMI_SwitchMode");
+    ENTER_PROC("SMI_SwitchMode");
 
-	pSmi->IsSwitching = TRUE;
-	ret = SMI_ModeInit(xf86Screens[scrnIndex], mode);
-	pSmi->IsSwitching = FALSE;
+    pSmi->IsSwitching = TRUE;
+    ret = SMI_ModeInit(xf86Screens[scrnIndex], mode);
+    pSmi->IsSwitching = FALSE;
 
-	LEAVE_PROC("SMI_SwitchMode");
-	return(ret);
+    LEAVE_PROC("SMI_SwitchMode");
+    return ret;
 }
 
 void
 SMI_LoadPalette(ScrnInfoPtr pScrn, int numColors, int *indicies, LOCO *colors,
 				VisualPtr pVisual)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int i;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int i;
 
-	ENTER_PROC("SMI_LoadPalette");
+    ENTER_PROC("SMI_LoadPalette");
 
-	/* Enable both the CRT and LCD DAC RAM paths, so both palettes are updated */
-    if ((pSmi->Chipset == SMI_LYNX3DM) || (pSmi->Chipset == SMI_COUGAR3DR)) 
-	{
-		CARD8 ccr66;
+    /* Enable both the CRT and LCD DAC RAM paths, so both palettes are updated */
+    if ((pSmi->Chipset == SMI_LYNX3DM) ||
+	(pSmi->Chipset == SMI_COUGAR3DR)) {
+	CARD8 ccr66;
 
-		ccr66  = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
-		ccr66 &= 0x0f;
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66, ccr66);
-	}
+	ccr66  = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66);
+	ccr66 &= 0x0f;
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66, ccr66);
+    }
 
-	for(i = 0; i < numColors; i++)
-	{
+    for(i = 0; i < numColors; i++) {
         DEBUG((VERBLEV, "pal[%d] = %d %d %d\n", indicies[i],
-           colors[indicies[i]].red, colors[indicies[i]].green, colors[indicies[i]].blue));
-		VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, indicies[i]);
-		VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].red);
-		VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].green);
-		VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].blue);
-	}
-
-	LEAVE_PROC("SMI_LoadPalette");
+        colors[indicies[i]].red, colors[indicies[i]].green, colors[indicies[i]].blue));
+	VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, indicies[i]);
+	VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].red);
+	VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].green);
+	VGAOUT8(pSmi, VGA_DAC_DATA, colors[indicies[i]].blue);
+    }
+
+    LEAVE_PROC("SMI_LoadPalette");
 }
 
 static void
 SMI_DisableVideo(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD8 tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD8 tmp;
 
-	if (!(tmp = VGAIN8(pSmi, VGA_DAC_MASK)))
-	  return;
-	pSmi->DACmask = tmp;
-	VGAOUT8(pSmi, VGA_DAC_MASK, 0);
+    if (!(tmp = VGAIN8(pSmi, VGA_DAC_MASK)))
+	return;
+    pSmi->DACmask = tmp;
+    VGAOUT8(pSmi, VGA_DAC_MASK, 0);
 }
 
 static void
 SMI_EnableVideo(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	VGAOUT8(pSmi, VGA_DAC_MASK, pSmi->DACmask);
+    VGAOUT8(pSmi, VGA_DAC_MASK, pSmi->DACmask);
 }
 
 
 void
 SMI_EnableMmio(ScrnInfoPtr pScrn)
 {
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD8 tmp;
-
-	ENTER_PROC("SMI_EnableMmio");
-
-	/*
-	 * Enable chipset (seen on uninitialized secondary cards) might not be
-	 * needed once we use the VGA softbooter
-	 */
-	vgaHWSetStdFuncs(hwp);
-
-	/* Enable linear mode */
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
-	tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
-	pSmi->SR18Value = tmp;					/* PDR#521 */
-	outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp | 0x11);
-
-	/* Enable 2D/3D Engine and Video Processor */
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
-	tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
-	pSmi->SR21Value = tmp;					/* PDR#521 */
-	outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp & ~0x03);
-
-	LEAVE_PROC("SMI_EnableMmio");
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD8 tmp;
+
+    ENTER_PROC("SMI_EnableMmio");
+
+    /*
+     * Enable chipset (seen on uninitialized secondary cards) might not be
+     * needed once we use the VGA softbooter
+     */
+    vgaHWSetStdFuncs(hwp);
+
+    /* Enable linear mode */
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
+    tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
+    pSmi->SR18Value = tmp;					/* PDR#521 */
+    outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp | 0x11);
+
+    /* Enable 2D/3D Engine and Video Processor */
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
+    tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
+    pSmi->SR21Value = tmp;					/* PDR#521 */
+    outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp & ~0x03);
+
+    LEAVE_PROC("SMI_EnableMmio");
 }
 
 void
 SMI_DisableMmio(ScrnInfoPtr pScrn)
 {
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_DisableMmio");
+    ENTER_PROC("SMI_DisableMmio");
 
-	vgaHWSetStdFuncs(hwp);
+    vgaHWSetStdFuncs(hwp);
 
-	/* Disable 2D/3D Engine and Video Processor */
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
-	outb(pSmi->PIOBase + VGA_SEQ_DATA, pSmi->SR21Value);	/* PDR#521 */
+    /* Disable 2D/3D Engine and Video Processor */
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x21);
+    outb(pSmi->PIOBase + VGA_SEQ_DATA, pSmi->SR21Value);	/* PDR#521 */
 
-	/* Disable linear mode */
-	outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
-	outb(pSmi->PIOBase + VGA_SEQ_DATA, pSmi->SR18Value);	/* PDR#521 */
+    /* Disable linear mode */
+    outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
+    outb(pSmi->PIOBase + VGA_SEQ_DATA, pSmi->SR18Value);	/* PDR#521 */
 
-	LEAVE_PROC("SMI_DisableMmio");
+    LEAVE_PROC("SMI_DisableMmio");
 }
 
 /* This function is used to debug, it prints out the contents of Lynx regs */
 static void
 SMI_PrintRegs(ScrnInfoPtr pScrn)
 {
-	unsigned char i;
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int vgaCRIndex = hwp->IOBase + VGA_CRTC_INDEX_OFFSET;
-	int vgaCRReg   = hwp->IOBase + VGA_CRTC_DATA_OFFSET;
-	int vgaStatus  = hwp->IOBase + VGA_IN_STAT_1_OFFSET;
-
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"START register dump ------------------\n");
-
-	xf86ErrorFVerb(VERBLEV, "MISCELLANEOUS OUTPUT\n    %02X\n",
-			VGAIN8(pSmi, VGA_MISC_OUT_R));
-
-	xf86ErrorFVerb(VERBLEV, "\nSEQUENCER\n"
-			"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
-	for (i = 0x00; i <= 0xAF; i++)
-	{
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
-		xf86ErrorFVerb(VERBLEV, "%02X ",
-				VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\nCRT CONTROLLER\n"
-			"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
-	for (i = 0x00; i <= 0xAD; i++)
-	{
-		if (i == 0x20) i = 0x30;
-		if (i == 0x50) i = 0x90;
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
-		xf86ErrorFVerb(VERBLEV, "%02X ",
-				VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRReg, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\nGRAPHICS CONTROLLER\n"
-			"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
-	for (i = 0x00; i <= 0x08; i++)
-	{
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
-		xf86ErrorFVerb(VERBLEV, "%02X ",
-				VGAIN8_INDEX(pSmi, VGA_GRAPH_INDEX, VGA_GRAPH_DATA, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\nATTRIBUTE 0CONTROLLER\n"
-			"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
-	for (i = 0x00; i <= 0x14; i++)
-	{
-		(void) VGAIN8(pSmi, vgaStatus);
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
-		xf86ErrorFVerb(VERBLEV, "%02X ",
-				VGAIN8_INDEX(pSmi, VGA_ATTR_INDEX, VGA_ATTR_DATA_R, i));
-	}
+    unsigned char i;
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int vgaCRIndex = hwp->IOBase + VGA_CRTC_INDEX_OFFSET;
+    int vgaCRReg   = hwp->IOBase + VGA_CRTC_DATA_OFFSET;
+    int vgaStatus  = hwp->IOBase + VGA_IN_STAT_1_OFFSET;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		"START register dump ------------------\n");
+
+    xf86ErrorFVerb(VERBLEV, "MISCELLANEOUS OUTPUT\n    %02X\n",
+		VGAIN8(pSmi, VGA_MISC_OUT_R));
+
+    xf86ErrorFVerb(VERBLEV, "\nSEQUENCER\n"
+		"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
+    for (i = 0x00; i <= 0xAF; i++) {
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
+	xf86ErrorFVerb(VERBLEV, "%02X ",
+	    VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\nCRT CONTROLLER\n"
+		"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
+    for (i = 0x00; i <= 0xAD; i++) {
+	if (i == 0x20) i = 0x30;
+	if (i == 0x50) i = 0x90;
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
+	xf86ErrorFVerb(VERBLEV, "%02X ",
+	    VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRReg, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\nGRAPHICS CONTROLLER\n"
+		"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
+    for (i = 0x00; i <= 0x08; i++) {
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
+	xf86ErrorFVerb(VERBLEV, "%02X ",
+	    VGAIN8_INDEX(pSmi, VGA_GRAPH_INDEX, VGA_GRAPH_DATA, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\nATTRIBUTE 0CONTROLLER\n"
+		"    x0 x1 x2 x3  x4 x5 x6 x7  x8 x9 xA xB  xC xD xE xF");
+    for (i = 0x00; i <= 0x14; i++) {
 	(void) VGAIN8(pSmi, vgaStatus);
-	VGAOUT8(pSmi, VGA_ATTR_INDEX, 0x20);
-
-	xf86ErrorFVerb(VERBLEV, "\n\nDPR    x0       x4       x8       xC");
-	for (i = 0x00; i <= 0x44; i += 4)
-	{
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_DPR(pSmi, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\nVPR    x0       x4       x8       xC");
-	for (i = 0x00; i <= 0x60; i += 4)
-	{
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_VPR(pSmi, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\nCPR    x0       x4       x8       xC");
-	for (i = 0x00; i <= 0x18; i += 4)
-	{
-		if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
-		xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_CPR(pSmi, i));
-	}
-
-	xf86ErrorFVerb(VERBLEV, "\n\n");
-	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
-			"END register dump --------------------\n");
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
+	xf86ErrorFVerb(VERBLEV, "%02X ",
+	    VGAIN8_INDEX(pSmi, VGA_ATTR_INDEX, VGA_ATTR_DATA_R, i));
+    }
+    (void) VGAIN8(pSmi, vgaStatus);
+    VGAOUT8(pSmi, VGA_ATTR_INDEX, 0x20);
+
+    xf86ErrorFVerb(VERBLEV, "\n\nDPR    x0       x4       x8       xC");
+    for (i = 0x00; i <= 0x44; i += 4) {
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_DPR(pSmi, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\nVPR    x0       x4       x8       xC");
+    for (i = 0x00; i <= 0x60; i += 4) {
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_VPR(pSmi, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\nCPR    x0       x4       x8       xC");
+    for (i = 0x00; i <= 0x18; i += 4) {
+	if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
+	xf86ErrorFVerb(VERBLEV, " %08lX", (unsigned long)READ_CPR(pSmi, i));
+    }
+
+    xf86ErrorFVerb(VERBLEV, "\n\n");
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
+		"END register dump --------------------\n");
 }
 
 /*
@@ -3394,212 +3041,197 @@ static void
 SMI_DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
 							  int flags)
 {
-	vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD8 SR01, SR20, SR21, SR22, SR23, SR24, SR31, SR34;
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD8 SR01, SR20, SR21, SR22, SR23, SR24, SR31, SR34;
 
-	ENTER_PROC("SMI_DisplayPowerManagementSet");
+    ENTER_PROC("SMI_DisplayPowerManagementSet");
 
-	/* If we already are in the requested DPMS mode, just return */
-	if (pSmi->CurrentDPMS == PowerManagementMode)
-	{
-		LEAVE_PROC("SMI_DisplayPowerManagementSet");
-		return;
-	}
+    /* If we already are in the requested DPMS mode, just return */
+    if (pSmi->CurrentDPMS == PowerManagementMode) {
+	LEAVE_PROC("SMI_DisplayPowerManagementSet");
+	return;
+    }
 
 #if 1 /* PDR#735 */
-	if (pSmi->useBIOS && pSmi->pInt10 != NULL)
-	{
-		pSmi->pInt10->ax = 0x4F10;
-		switch (PowerManagementMode)
-		{
-			case DPMSModeOn:
-				pSmi->pInt10->bx = 0x0001;
-				break;
-
-			case DPMSModeStandby:
-				pSmi->pInt10->bx = 0x0101;
-				break;
-
-			case DPMSModeSuspend:
-				pSmi->pInt10->bx = 0x0201;
-				break;
-
-			case DPMSModeOff:
-				pSmi->pInt10->bx = 0x0401;
-				break;
-		}
-		pSmi->pInt10->cx = 0x0000;
-		pSmi->pInt10->num = 0x10;
-		xf86ExecX86int10(pSmi->pInt10);
-		if (pSmi->pInt10->ax == 0x004F)
-		{
-			pSmi->CurrentDPMS = PowerManagementMode;
+    if (pSmi->useBIOS && pSmi->pInt10 != NULL) {
+	pSmi->pInt10->ax = 0x4F10;
+	switch (PowerManagementMode) {
+	case DPMSModeOn:
+	    pSmi->pInt10->bx = 0x0001;
+	    break;
+	case DPMSModeStandby:
+	    pSmi->pInt10->bx = 0x0101;
+	    break;
+	case DPMSModeSuspend:
+	    pSmi->pInt10->bx = 0x0201;
+	    break;
+	case DPMSModeOff:
+	    pSmi->pInt10->bx = 0x0401;
+	    break;
+	}
+	pSmi->pInt10->cx = 0x0000;
+	pSmi->pInt10->num = 0x10;
+	xf86ExecX86int10(pSmi->pInt10);
+	if (pSmi->pInt10->ax == 0x004F) {
+	    pSmi->CurrentDPMS = PowerManagementMode;
 #if 1 /* PDR#835 */
-			if (PowerManagementMode == DPMSModeOn)
-			{
-				SR01 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01);
-				VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01,
-						SR01 & ~0x20);
-			}
+	    if (PowerManagementMode == DPMSModeOn) {
+		SR01 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01);
+		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01,
+				SR01 & ~0x20);
+	    }
 #endif
-			LEAVE_PROC("SMI_DisplayPowerManagementSet");
-			return;
-		}
+	    LEAVE_PROC("SMI_DisplayPowerManagementSet");
+	    return;
 	}
+    }
 #endif
 
-	/* Save the current SR registers */
-	if (pSmi->CurrentDPMS == DPMSModeOn)
-	{
-		pSmi->DPMS_SR20 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20);
-		pSmi->DPMS_SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
-		pSmi->DPMS_SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
-		pSmi->DPMS_SR34 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34);
-	}
-
-	/* Read the required SR registers for the DPMS handler */
-	SR01 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01);
-	SR20 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20);
-	SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
-	SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22);
-	SR23 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23);
-	SR24 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x24);
-	SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
-	SR34 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34);
-
-	switch (PowerManagementMode)
-	{
-		case DPMSModeOn:
-			/* Screen On: HSync: On, VSync : On */
-			SR01 &= ~0x20;
-			SR20  = pSmi->DPMS_SR20;
-			SR21  = pSmi->DPMS_SR21;
-			SR22 &= ~0x30;
-			SR23 &= ~0xC0;
-			SR24 |= 0x01;
-			SR31  = pSmi->DPMS_SR31;
-			SR34  = pSmi->DPMS_SR34;
-			break;
-
-		case DPMSModeStandby:
-			/* Screen: Off; HSync: Off, VSync: On */
-			SR01 |= 0x20;
-			SR20  = (SR20 & ~0xB0) | 0x10;
-			SR21 |= 0x88;
-			SR22  = (SR22 & ~0x30) | 0x10;
-			SR23  = (SR23 & ~0x07) | 0xD8;
-			SR24 &= ~0x01;
-			SR31  = (SR31 & ~0x07) | 0x00;
-			SR34 |= 0x80;
-			break;
-
-		case DPMSModeSuspend:
-			/* Screen: Off; HSync: On, VSync: Off */
-			SR01 |= 0x20;
-			SR20  = (SR20 & ~0xB0) | 0x10;
-			SR21 |= 0x88;
-			SR22  = (SR22 & ~0x30) | 0x20;
-			SR23  = (SR23 & ~0x07) | 0xD8;
-			SR24 &= ~0x01;
-			SR31  = (SR31 & ~0x07) | 0x00;
-			SR34 |= 0x80;
-			break;
-
-		case DPMSModeOff:
-			/* Screen: Off; HSync: Off, VSync: Off */
-			SR01 |= 0x20;
-			SR20  = (SR20 & ~0xB0) | 0x10;
-			SR21 |= 0x88;
-			SR22  = (SR22 & ~0x30) | 0x30;
-			SR23  = (SR23 & ~0x07) | 0xD8;
-			SR24 &= ~0x01;
-			SR31  = (SR31 & ~0x07) | 0x00;
-			SR34 |= 0x80;
-			break;
-
-		default:
-			xf86ErrorFVerb(VERBLEV, "Invalid PowerManagementMode %d passed to "
-					"SMI_DisplayPowerManagementSet\n", PowerManagementMode);
-			LEAVE_PROC("SMI_DisplayPowerManagementSet");
-			return;
-	}
-
-	/* Wait for vertical retrace */
-	while (hwp->readST01(hwp) & 0x8) ;
-	while (!(hwp->readST01(hwp) & 0x8)) ;
-
-	/* Write the registers */
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01, SR01);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34, SR34);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31, SR31);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20, SR20);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22, SR22);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23, SR23);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, SR21);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x24, SR24);
-
-	/* Save the current power state */
-	pSmi->CurrentDPMS = PowerManagementMode;
-
+    /* Save the current SR registers */
+    if (pSmi->CurrentDPMS == DPMSModeOn) {
+	pSmi->DPMS_SR20 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20);
+	pSmi->DPMS_SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
+	pSmi->DPMS_SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
+	pSmi->DPMS_SR34 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34);
+    }
+
+    /* Read the required SR registers for the DPMS handler */
+    SR01 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01);
+    SR20 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20);
+    SR21 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
+    SR22 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22);
+    SR23 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23);
+    SR24 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x24);
+    SR31 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31);
+    SR34 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34);
+
+    switch (PowerManagementMode) {
+    case DPMSModeOn:
+	/* Screen On: HSync: On, VSync : On */
+	SR01 &= ~0x20;
+	SR20  = pSmi->DPMS_SR20;
+	SR21  = pSmi->DPMS_SR21;
+	SR22 &= ~0x30;
+	SR23 &= ~0xC0;
+	SR24 |= 0x01;
+	SR31  = pSmi->DPMS_SR31;
+	SR34  = pSmi->DPMS_SR34;
+	break;
+    case DPMSModeStandby:
+	/* Screen: Off; HSync: Off, VSync: On */
+	SR01 |= 0x20;
+	SR20  = (SR20 & ~0xB0) | 0x10;
+	SR21 |= 0x88;
+	SR22  = (SR22 & ~0x30) | 0x10;
+	SR23  = (SR23 & ~0x07) | 0xD8;
+	SR24 &= ~0x01;
+	SR31  = (SR31 & ~0x07) | 0x00;
+	SR34 |= 0x80;
+	break;
+    case DPMSModeSuspend:
+	/* Screen: Off; HSync: On, VSync: Off */
+	SR01 |= 0x20;
+	SR20  = (SR20 & ~0xB0) | 0x10;
+	SR21 |= 0x88;
+	SR22  = (SR22 & ~0x30) | 0x20;
+	SR23  = (SR23 & ~0x07) | 0xD8;
+	SR24 &= ~0x01;
+	SR31  = (SR31 & ~0x07) | 0x00;
+	SR34 |= 0x80;
+	break;
+    case DPMSModeOff:
+	/* Screen: Off; HSync: Off, VSync: Off */
+	SR01 |= 0x20;
+	SR20  = (SR20 & ~0xB0) | 0x10;
+	SR21 |= 0x88;
+	SR22  = (SR22 & ~0x30) | 0x30;
+	SR23  = (SR23 & ~0x07) | 0xD8;
+	SR24 &= ~0x01;
+	SR31  = (SR31 & ~0x07) | 0x00;
+	SR34 |= 0x80;
+	break;
+    default:
+	xf86ErrorFVerb(VERBLEV, "Invalid PowerManagementMode %d passed to "
+		"SMI_DisplayPowerManagementSet\n", PowerManagementMode);
 	LEAVE_PROC("SMI_DisplayPowerManagementSet");
+	return;
+    }
+
+    /* Wait for vertical retrace */
+    while (hwp->readST01(hwp) & 0x8) ;
+    while (!(hwp->readST01(hwp) & 0x8)) ;
+
+    /* Write the registers */
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01, SR01);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x34, SR34);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31, SR31);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20, SR20);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22, SR22);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23, SR23);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, SR21);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x24, SR24);
+
+    /* Save the current power state */
+    pSmi->CurrentDPMS = PowerManagementMode;
+
+    LEAVE_PROC("SMI_DisplayPowerManagementSet");
 }
 
 static void
 SMI_ProbeDDC(ScrnInfoPtr pScrn, int index)
 {
-	vbeInfoPtr pVbe;
-	if (xf86LoadSubModule(pScrn, "vbe"))
-	{
-		pVbe = VBEInit(NULL, index);
-		ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
-		vbeFree(pVbe);
-	}
+    vbeInfoPtr pVbe;
+    if (xf86LoadSubModule(pScrn, "vbe")) {
+	pVbe = VBEInit(NULL, index);
+	ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
+	vbeFree(pVbe);
+    }
 }
 
 static unsigned int
 SMI_ddc1Read(ScrnInfoPtr pScrn)
 {
-	register vgaHWPtr hwp = VGAHWPTR(pScrn);
-	SMIPtr pSmi = SMIPTR(pScrn);
-	unsigned int ret;
+    register vgaHWPtr hwp = VGAHWPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
+    unsigned int ret;
 
-	ENTER_PROC("SMI_ddc1Read");
+    ENTER_PROC("SMI_ddc1Read");
 
-	while (hwp->readST01(hwp) & 0x8) ;
-	while (!(hwp->readST01(hwp) & 0x8)) ;
+    while (hwp->readST01(hwp) & 0x8) ;
+    while (!(hwp->readST01(hwp) & 0x8)) ;
 
-	ret = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72) & 0x08;
+    ret = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72) & 0x08;
 
-	LEAVE_PROC("SMI_ddc1Read");
-	return(ret);
+    LEAVE_PROC("SMI_ddc1Read");
+    return ret;
 }
 
 static Bool
 SMI_ddc1(int scrnIndex)
 {
-	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	Bool success = FALSE;
-	xf86MonPtr pMon;
-	unsigned char tmp;
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    Bool success = FALSE;
+    xf86MonPtr pMon;
+    unsigned char tmp;
 
-	ENTER_PROC("SMI_ddc1");
+    ENTER_PROC("SMI_ddc1");
 
-	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp | 0x20);
+    tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp | 0x20);
 
-	pMon = xf86PrintEDID(xf86DoEDID_DDC1(scrnIndex,
-					     vgaHWddc1SetSpeedWeak(),
-					     SMI_ddc1Read));
-	if (pMon != NULL)
-	{
-		success = TRUE;
-	}
-	xf86SetDDCproperties(pScrn, pMon);
+    pMon = xf86PrintEDID(xf86DoEDID_DDC1(scrnIndex,
+					 vgaHWddc1SetSpeedWeak(),
+					 SMI_ddc1Read));
+    if (pMon != NULL) {
+	success = TRUE;
+    }
+    xf86SetDDCproperties(pScrn, pMon);
 
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp);
 
-	LEAVE_PROC("SMI_ddc1");
-	return(success);
+    LEAVE_PROC("SMI_ddc1");
+    return success;
 }
+
diff --git a/src/smi_hwcurs.c b/src/smi_hwcurs.c
index 003e7ef..ef55896 100644
--- a/src/smi_hwcurs.c
+++ b/src/smi_hwcurs.c
@@ -40,184 +40,160 @@ authorization from the XFree86 Project and Silicon Motion.
 static unsigned char *
 SMI_RealizeCursor(xf86CursorInfoPtr infoPtr, CursorPtr pCurs)
 {
-	SMIPtr pSmi = SMIPTR(infoPtr->pScrn);
-	CursorBitsPtr bits = pCurs->bits;
-	unsigned char * ram;
-	unsigned char * psource = bits->source;
-	unsigned char * pmask = bits->mask;
-	int x, y, srcwidth, i;
-
-	ENTER_PROC("SMI_RealizeCursor");
-
-	/* Allocate memory */
-	ram = (unsigned char *) xcalloc(1, 1024);
-	if (ram == NULL)
-	{
-		LEAVE_PROC("SMI_RealizeCursor");
-		return(NULL);
+    SMIPtr pSmi = SMIPTR(infoPtr->pScrn);
+    CursorBitsPtr bits = pCurs->bits;
+    unsigned char * ram;
+    unsigned char * psource = bits->source;
+    unsigned char * pmask = bits->mask;
+    int x, y, srcwidth, i;
+
+    ENTER_PROC("SMI_RealizeCursor");
+
+    /* Allocate memory */
+    ram = (unsigned char *) xcalloc(1, 1024);
+    if (ram == NULL) {
+	LEAVE_PROC("SMI_RealizeCursor");
+	return NULL;
+    }
+
+    /* Calculate cursor information */
+    srcwidth = ((bits->width + 31) / 8) & ~3;
+    i = 0;
+
+    switch (pSmi->rotate) {
+    default:
+	/* Copy cursor image */
+	for (y = 0; y < min(MAX_CURSOR, bits->height); y++) {
+	    for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++) {
+		unsigned char mask   = byte_reversed[*pmask++];
+		unsigned char source = byte_reversed[*psource++] & mask;
+
+		ram[i++] = ~mask;
+		ram[i++] = source;
+		if (i & 4) i += 4;
+	    }
+
+	    pmask   += srcwidth - x;
+	    psource += srcwidth - x;
+
+	    /* Fill remaining part of line with no shape */
+	    for (; x < MAX_CURSOR / 8; x++) {
+		ram[i++] = 0xFF;
+		ram[i++] = 0x00;
+		if (i & 4) i += 4;
+	    }
 	}
 
-	/* Calculate cursor information */
-	srcwidth = ((bits->width + 31) / 8) & ~3;
-	i = 0;
-
-	switch (pSmi->rotate)
-	{
-		default:
-			/* Copy cursor image */
-			for (y = 0; y < min(MAX_CURSOR, bits->height); y++)
-			{
-				for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++)
-				{
-					unsigned char mask   = byte_reversed[*pmask++];
-					unsigned char source = byte_reversed[*psource++] & mask;
-
-					ram[i++] = ~mask;
-					ram[i++] = source;
-					if (i & 4) i += 4;
-				}
-
-				pmask   += srcwidth - x;
-				psource += srcwidth - x;
-
-				/* Fill remaining part of line with no shape */
-				for (; x < MAX_CURSOR / 8; x++)
-				{
-					ram[i++] = 0xFF;
-					ram[i++] = 0x00;
-					if (i & 4) i += 4;
-				}
-			}
+	/* Fill remaining part of memory with no shape */
+	for (; y < MAX_CURSOR; y++) {
+	    for (x = 0; x < MAX_CURSOR / 8; x++) {
+		ram[i++] = 0xFF;
+		ram[i++] = 0x00;
+		if (i & 4) i += 4;
+	    }
+	}
+	break;
+    case SMI_ROTATE_CW:
+	/* Initialize cursor memory */
+	for (i = 0; i < 1024;) {
+	    ram[i++] = 0xFF;
+	    ram[i++] = 0x00;
+	    if (i & 4) i += 4;
+	}
 
-			/* Fill remaining part of memory with no shape */
-			for (; y < MAX_CURSOR; y++)
-			{
-				for (x = 0; x < MAX_CURSOR / 8; x++)
-				{
-					ram[i++] = 0xFF;
-					ram[i++] = 0x00;
-					if (i & 4) i += 4;
-				}
-			}
-			break;
-
-		case SMI_ROTATE_CW:
-			/* Initialize cursor memory */
-			for (i = 0; i < 1024;)
-			{
-				ram[i++] = 0xFF;
-				ram[i++] = 0x00;
-				if (i & 4) i += 4;
+	/* Rotate cursor image */
+	for (y = 0; y < min(MAX_CURSOR, bits->height); y++) {
+	    unsigned char bitmask = 0x01 << (y & 7);
+	    int           index   = ((MAX_CURSOR - y - 1) / 8) * 2;
+	    if (index & 4) index += 4;
+
+	    for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++) {
+		unsigned char mask   = *pmask++;
+		unsigned char source = *psource++ & mask;
+
+		i = index + (x * 8) * 16;
+		if (mask || (source & mask)) {
+		    unsigned char bit;
+		    for (bit = 0x01; bit; bit <<= 1) {
+			if (mask & bit) {
+			    ram[i + 0] &= ~bitmask;
 			}
 
-			/* Rotate cursor image */
-			for (y = 0; y < min(MAX_CURSOR, bits->height); y++)
-			{
-				unsigned char bitmask = 0x01 << (y & 7);
-				int           index   = ((MAX_CURSOR - y - 1) / 8) * 2;
-				if (index & 4) index += 4;
-
-				for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++)
-				{
-					unsigned char mask   = *pmask++;
-					unsigned char source = *psource++ & mask;
-
-					i = index + (x * 8) * 16;
-					if (mask || (source & mask))
-					{
-						unsigned char bit;
-						for (bit = 0x01; bit; bit <<= 1)
-						{
-							if (mask & bit)
-							{
-								ram[i + 0] &= ~bitmask;
-							}
-
-							if (source & bit)
-							{
-								ram[i + 1] |= bitmask;
-							}
-
-							i += 16;
-						}
-					}
-				}
-
-				pmask   += srcwidth - x;
-				psource += srcwidth - x;
+			if (source & bit) {
+			    ram[i + 1] |= bitmask;
 			}
-			break;
-
-		case SMI_ROTATE_CCW:
-			/* Initialize cursor memory */
-			for (i = 0; i < 1024;)
-			{
-				ram[i++] = 0xFF;
-				ram[i++] = 0x00;
-				if (i & 4) i += 4;
+
+			i += 16;
+		    }
+		}
+	    }
+
+	    pmask   += srcwidth - x;
+	    psource += srcwidth - x;
+	}
+	break;
+    case SMI_ROTATE_CCW:
+	/* Initialize cursor memory */
+	for (i = 0; i < 1024;) {
+	    ram[i++] = 0xFF;
+	    ram[i++] = 0x00;
+	    if (i & 4) i += 4;
+	}
+
+	/* Rotate cursor image */
+	for (y = 0; y < min(MAX_CURSOR, bits->height); y++) {
+	    unsigned char bitmask = 0x80 >> (y & 7);
+	    int		  index	  = (y >> 3) * 2;
+	    if (index & 4) index += 4;
+
+	    for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++) {
+		unsigned char mask   = *pmask++;
+		unsigned char source = *psource++ & mask;
+
+		i = index + (MAX_CURSOR - x * 8 - 1) * 16;
+		if (mask || (source & mask)) {
+		    unsigned char bit;
+		    for (bit = 0x01; bit; bit <<= 1) {
+			if (mask & bit) {
+			    ram[i + 0] &= ~bitmask;
 			}
 
-			/* Rotate cursor image */
-			for (y = 0; y < min(MAX_CURSOR, bits->height); y++)
-			{
-				unsigned char bitmask = 0x80 >> (y & 7);
-				int			  index	  = (y >> 3) * 2;
-				if (index & 4) index += 4;
-
-				for (x = 0; x < min(MAX_CURSOR / 8, srcwidth); x++)
-				{
-					unsigned char mask   = *pmask++;
-					unsigned char source = *psource++ & mask;
-
-					i = index + (MAX_CURSOR - x * 8 - 1) * 16;
-					if (mask || (source & mask))
-					{
-						unsigned char bit;
-						for (bit = 0x01; bit; bit <<= 1)
-						{
-							if (mask & bit)
-							{
-								ram[i + 0] &= ~bitmask;
-							}
-
-							if (source & bit)
-							{
-								ram[i + 1] |= bitmask;
-							}
-
-							i -= 16;
-						}
-					}
-				}
-
-				pmask   += srcwidth - x;
-				psource += srcwidth - x;
+			if (source & bit) {
+			    ram[i + 1] |= bitmask;
 			}
-			break;
+
+			i -= 16;
+		    }
+		}
+	    }
+
+	    pmask   += srcwidth - x;
+	    psource += srcwidth - x;
 	}
+	break;
+    }
 
-	LEAVE_PROC("SMI_RealizeCursor");
-	return(ram);
+    LEAVE_PROC("SMI_RealizeCursor");
+    return ram;
 }
 
 static void
 SMI_LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD8 tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD8 tmp;
 
-	ENTER_PROC("SMI_LoadCursorImage");
+    ENTER_PROC("SMI_LoadCursorImage");
 
     /* Load storage location. */
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x80,
-			pSmi->FBCursorOffset / 2048);
-	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81) & 0x80;
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81,
-			tmp | ((pSmi->FBCursorOffset / 2048) >> 8));
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x80,
+		  pSmi->FBCursorOffset / 2048);
+    tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81) & 0x80;
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81,
+		  tmp | ((pSmi->FBCursorOffset / 2048) >> 8));
 
     /* Program FPR copy when on the 730 */
-    if (pSmi->Chipset == SMI_COUGAR3DR)
-    {
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
         CARD32 fpr15c;
 
         /* put address in upper word, and disable the cursor */
@@ -226,27 +202,26 @@ SMI_LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src)
         WRITE_FPR(pSmi, FPR15C, fpr15c);
     }
 
-	/* Copy cursor image to framebuffer storage */
-	memcpy(pSmi->FBBase + pSmi->FBCursorOffset, src, 1024);
+    /* Copy cursor image to framebuffer storage */
+    memcpy(pSmi->FBBase + pSmi->FBCursorOffset, src, 1024);
 
-	LEAVE_PROC("SMI_LoadCursorImage");
+    LEAVE_PROC("SMI_LoadCursorImage");
 }
 
 static void
 SMI_ShowCursor(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	char tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    char tmp;
 
-	ENTER_PROC("SMI_ShowCursor");
+    ENTER_PROC("SMI_ShowCursor");
 
-	/* Show cursor */
-	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, tmp | 0x80);
+    /* Show cursor */
+    tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, tmp | 0x80);
 
     /* Program FPR copy when on the 730 */
-    if (pSmi->Chipset == SMI_COUGAR3DR)
-    {
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
         CARD32 fpr15c;
 
         /* turn on the top bit */
@@ -255,24 +230,23 @@ SMI_ShowCursor(ScrnInfoPtr pScrn)
         WRITE_FPR(pSmi, FPR15C, fpr15c);
     }
 
-	LEAVE_PROC("SMI_ShowCursor");
+    LEAVE_PROC("SMI_ShowCursor");
 }
 
 static void
 SMI_HideCursor(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	char tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    char tmp;
 
-	ENTER_PROC("SMI_HideCursor");
+    ENTER_PROC("SMI_HideCursor");
 
-	/* Hide cursor */
-	tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, tmp & ~0x80);
+    /* Hide cursor */
+    tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, tmp & ~0x80);
 
     /* Program FPR copy when on the 730 */
-    if (pSmi->Chipset == SMI_COUGAR3DR)
-    {
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
         CARD32 fpr15c;
 
         /* turn off the top bit */
@@ -281,83 +255,63 @@ SMI_HideCursor(ScrnInfoPtr pScrn)
         WRITE_FPR(pSmi, FPR15C, fpr15c);
     }
 
-	LEAVE_PROC("SMI_HideCursor");
+    LEAVE_PROC("SMI_HideCursor");
 }
 
 static void
 SMI_SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int xoff, yoff;
-
-	ENTER_PROC("SMI_SetCursorPosition");
-
-	/* Calculate coordinates for rotation */
-	switch (pSmi->rotate)
-	{
-		default:
-			xoff = x;
-			yoff = y;
-			break;
-
-		case SMI_ROTATE_CW:
-			xoff = pSmi->ShadowHeight - y - MAX_CURSOR;
-			yoff = x;
-			break;
-
-		case SMI_ROTATE_CCW:
-			xoff = y;
-			yoff = pSmi->ShadowWidth - x - MAX_CURSOR;
-			break;
-	}
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int xoff, yoff;
+
+    ENTER_PROC("SMI_SetCursorPosition");
+
+    /* Calculate coordinates for rotation */
+    switch (pSmi->rotate) {
+    default:
+	xoff = x;
+	yoff = y;
+	break;
+    case SMI_ROTATE_CW:
+	xoff = pSmi->ShadowHeight - y - MAX_CURSOR;
+	yoff = x;
+	break;
+    case SMI_ROTATE_CCW:
+	xoff = y;
+	yoff = pSmi->ShadowWidth - x - MAX_CURSOR;
+	break;
+    }
 
-	/* Program coordinates */
-	if (xoff >= 0)
-	{
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x88, xoff & 0xFF);
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x89,
-				(xoff >> 8) & 0x07);
-	}
-	else
-	{
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x88,
-				(-xoff) & (MAX_CURSOR - 1));
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x89, 0x08);
-	}
+    /* Program coordinates */
+    if (xoff >= 0) {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x88, xoff & 0xFF);
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x89, (xoff >> 8) & 0x07);
+    } else {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x88, (-xoff) & (MAX_CURSOR - 1));
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x89, 0x08);
+    }
 
-	if (yoff >= 0)
-	{
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8A, yoff & 0xFF);
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8B,
-				(yoff >> 8) & 0x07);
-	}
-	else
-	{
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8A,
-				(-yoff) & (MAX_CURSOR - 1));
-		VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8B, 0x08);
-	}
+    if (yoff >= 0) {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8A, yoff & 0xFF);
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8B, (yoff >> 8) & 0x07);
+    } else {
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8A, (-yoff) & (MAX_CURSOR - 1));
+	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8B, 0x08);
+    }
 
     /* Program FPR copy when on the 730 */
-    if (pSmi->Chipset == SMI_COUGAR3DR)
-    {
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
         CARD32 fpr158;
 
-        if (xoff >= 0)
-        {
+        if (xoff >= 0) {
             fpr158 = (xoff & FPR158_MASK_MAXBITS)<<16;
-        }
-        else
-        {
+        } else {
             fpr158 = (((-xoff) & FPR158_MASK_MAXBITS) | FPR158_MASK_BOUNDARY)<<16;
         }
 
-        if (yoff >= 0)
-        {
+        if (yoff >= 0) {
             fpr158 |= (yoff & FPR158_MASK_MAXBITS);
-        }
-        else
-        {
+        } else {
             fpr158 |= (((-yoff) & FPR158_MASK_MAXBITS) | FPR158_MASK_BOUNDARY);
         }
 
@@ -366,34 +320,33 @@ SMI_SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
 
     }
 
-	LEAVE_PROC("SMI_SetCursorPosition");
+    LEAVE_PROC("SMI_SetCursorPosition");
 }
 
 static void
 SMI_SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	unsigned char packedFG, packedBG;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    unsigned char packedFG, packedBG;
 
-	ENTER_PROC("SMI_SetCursorColors");
+    ENTER_PROC("SMI_SetCursorColors");
 
-	/* Pack the true color into 8 bit */
-	packedFG = (fg & 0xE00000) >> 16
-			 | (fg & 0x00E000) >> 11
-			 | (fg & 0x0000C0) >> 6
-			 ;
-	packedBG = (bg & 0xE00000) >> 16
-			 | (bg & 0x00E000) >> 11
-			 | (bg & 0x0000C0) >> 6
-			 ;
+    /* Pack the true color into 8 bit */
+    packedFG = (fg & 0xE00000) >> 16
+	     | (fg & 0x00E000) >> 11
+	     | (fg & 0x0000C0) >> 6
+	     ;
+    packedBG = (bg & 0xE00000) >> 16
+	     | (bg & 0x00E000) >> 11
+	     | (bg & 0x0000C0) >> 6
+	     ;
 
-	/* Program the colors */
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8C, packedFG);
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8D, packedBG);
+    /* Program the colors */
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8C, packedFG);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x8D, packedBG);
 
     /* Program FPR copy when on the 730 */
-    if (pSmi->Chipset == SMI_COUGAR3DR)
-    {
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
         CARD32 fpr15c;
 
         fpr15c  = READ_FPR(pSmi, FPR15C) & FPR15C_MASK_HWCADDREN;
@@ -408,44 +361,44 @@ SMI_SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
 Bool
 SMI_HWCursorInit(ScreenPtr pScreen)
 {
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	xf86CursorInfoPtr infoPtr;
-	Bool ret;
-
-	ENTER_PROC("SMI_HWCursorInit");
-
-	/* Create cursor infor record */
-	infoPtr = xf86CreateCursorInfoRec();
-	if (infoPtr == NULL)
-	{
-		LEAVE_PROC("SMI_HWCursorInit");
-		return(FALSE);
-	}
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    xf86CursorInfoPtr infoPtr;
+    Bool ret;
+
+    ENTER_PROC("SMI_HWCursorInit");
+
+    /* Create cursor infor record */
+    infoPtr = xf86CreateCursorInfoRec();
+    if (infoPtr == NULL) {
+	LEAVE_PROC("SMI_HWCursorInit");
+	return FALSE;
+    }
 
     pSmi->CursorInfoRec = infoPtr;
 
-	/* Fill in the information */
+    /* Fill in the information */
     infoPtr->MaxWidth  = MAX_CURSOR;
     infoPtr->MaxHeight = MAX_CURSOR;
-    infoPtr->Flags	   = HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8
-					   | HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK
-					   | HARDWARE_CURSOR_AND_SOURCE_WITH_MASK
-					   | HARDWARE_CURSOR_BIT_ORDER_MSBFIRST
-					   | HARDWARE_CURSOR_TRUECOLOR_AT_8BPP
-					   | HARDWARE_CURSOR_INVERT_MASK;
+    infoPtr->Flags     = HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8
+		       | HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK
+		       | HARDWARE_CURSOR_AND_SOURCE_WITH_MASK
+		       | HARDWARE_CURSOR_BIT_ORDER_MSBFIRST
+		       | HARDWARE_CURSOR_TRUECOLOR_AT_8BPP
+		       | HARDWARE_CURSOR_INVERT_MASK;
 
     infoPtr->SetCursorColors   = SMI_SetCursorColors;
     infoPtr->SetCursorPosition = SMI_SetCursorPosition;
     infoPtr->LoadCursorImage   = SMI_LoadCursorImage;
     infoPtr->HideCursor        = SMI_HideCursor;
     infoPtr->ShowCursor        = SMI_ShowCursor;
-	infoPtr->RealizeCursor	   = SMI_RealizeCursor;
+    infoPtr->RealizeCursor     = SMI_RealizeCursor;
     infoPtr->UseHWCursor       = NULL;
 
-	/* Proceed with cursor initialization */
+    /* Proceed with cursor initialization */
     ret = xf86InitCursor(pScreen, infoPtr);
 
-	LEAVE_PROC("SMI_HWCursorInit");
-	return(ret);
+    LEAVE_PROC("SMI_HWCursorInit");
+    return ret;
 }
+
diff --git a/src/smi_i2c.c b/src/smi_i2c.c
index f4aa19d..959b5b6 100644
--- a/src/smi_i2c.c
+++ b/src/smi_i2c.c
@@ -55,64 +55,62 @@ authorization from the XFree86 Project and Silicon Motion.
 static void
 SMI_I2CPutBits(I2CBusPtr b, int clock,  int data)
 {
-	SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
-	unsigned int reg = 0x30;
+    SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
+    unsigned int reg = 0x30;
 
-	ENTER_PROC("SMI_I2CPutBits");
+    ENTER_PROC("SMI_I2CPutBits");
 
-	if (clock) reg |= 0x01;
-	if (data)  reg |= 0x02;
+    if (clock) reg |= 0x01;
+    if (data)  reg |= 0x02;
 
-	VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, reg);
+    VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, reg);
 
-	LEAVE_PROC("SMI_I2CPutBits");
+    LEAVE_PROC("SMI_I2CPutBits");
 }
 
 static void
 SMI_I2CGetBits(I2CBusPtr b, int *clock, int *data)
 {
-	SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
-	unsigned int reg = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
+    SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
+    unsigned int reg = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
 
-	ENTER_PROC("SMI_I2CGetBits");
+    ENTER_PROC("SMI_I2CGetBits");
 
-	*clock = reg & 0x04;
-	*data  = reg & 0x08;
+    *clock = reg & 0x04;
+    *data  = reg & 0x08;
 
-	LEAVE_PROC("SMI_I2CGetBits");
+    LEAVE_PROC("SMI_I2CGetBits");
 }
 
 Bool
 SMI_I2CInit(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-
-	ENTER_PROC("SMI_I2CInit");
-
-	if (pSmi->I2C == NULL)
-	{
-		I2CBusPtr I2CPtr = xf86CreateI2CBusRec();
-		if (I2CPtr == NULL)
-		{
-			LEAVE_PROC("SMI_I2CInit");
-			return(FALSE);
-		}
-
-		I2CPtr->BusName    = "I2C bus";
-		I2CPtr->scrnIndex  = pScrn->scrnIndex;
-		I2CPtr->I2CPutBits = SMI_I2CPutBits;
-		I2CPtr->I2CGetBits = SMI_I2CGetBits;
-
-		if (!xf86I2CBusInit(I2CPtr))
-		{
-			xf86DestroyI2CBusRec(I2CPtr, TRUE, TRUE);
-			LEAVE_PROC("SMI_I2CInit");
-			return(FALSE);
-		}
-
-		pSmi->I2C = I2CPtr;
+    SMIPtr pSmi = SMIPTR(pScrn);
+
+    ENTER_PROC("SMI_I2CInit");
+
+    if (pSmi->I2C == NULL) {
+	I2CBusPtr I2CPtr = xf86CreateI2CBusRec();
+	if (I2CPtr == NULL) {
+	    LEAVE_PROC("SMI_I2CInit");
+	    return FALSE;
 	}
 
-	LEAVE_PROC("SMI_I2CInit");
-	return(TRUE);
+	I2CPtr->BusName    = "I2C bus";
+	I2CPtr->scrnIndex  = pScrn->scrnIndex;
+	I2CPtr->I2CPutBits = SMI_I2CPutBits;
+	I2CPtr->I2CGetBits = SMI_I2CGetBits;
+
+	if (!xf86I2CBusInit(I2CPtr)) {
+	    xf86DestroyI2CBusRec(I2CPtr, TRUE, TRUE);
+	    LEAVE_PROC("SMI_I2CInit");
+	    return FALSE;
+	}
+
+	pSmi->I2C = I2CPtr;
+    }
+
+    LEAVE_PROC("SMI_I2CInit");
+    return TRUE;
 }
+
diff --git a/src/smi_shadow.c b/src/smi_shadow.c
index 10cfe4d..5b6e65a 100644
--- a/src/smi_shadow.c
+++ b/src/smi_shadow.c
@@ -47,141 +47,128 @@ authorization from the XFree86 Project and Silicon Motion.
 |*=============================================================================
 |*
 |*  PARAMETERS:		pScrn	Pointer to ScrnInfo structure.
-|*					num		Number of boxes to refresh.
-|*					pbox	Pointer to an array of boxes to refresh.
+|*			num	Number of boxes to refresh.
+|*			pbox	Pointer to an array of boxes to refresh.
 |*
 |*  DESCRIPTION:	Refresh a portion of the shadow buffer to the visual screen
-|*					buffer.  This is mainly used for rotation purposes.
-|*												y
+|*			buffer.  This is mainly used for rotation purposes.
+|*
 |*  RETURNS:		Nothing.
 |*
 \******************************************************************************/
 void SMI_RefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int width, height, srcX, srcY, destX, destY;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int width, height, srcX, srcY, destX, destY;
 
-	ENTER_PROC("SMI_RefreshArea");
+    ENTER_PROC("SMI_RefreshArea");
 
-	/* #671 */
-	if (pSmi->polyLines)
-	{
-		pSmi->polyLines = FALSE;
-		return;
-	}
+    /* #671 */
+    if (pSmi->polyLines) {
+	pSmi->polyLines = FALSE;
+	return;
+    }
 
-	if (pSmi->rotate)
-	{
-		/* IF we need to do rotation, setup the hardware here. */
-		WaitIdleEmpty();
-		WRITE_DPR(pSmi, 0x10, pSmi->ShadowPitch);
-		WRITE_DPR(pSmi, 0x3C, pSmi->ShadowPitch);
-		WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
-	}
+    if (pSmi->rotate) {
+	/* IF we need to do rotation, setup the hardware here. */
+	WaitIdleEmpty();
+	WRITE_DPR(pSmi, 0x10, pSmi->ShadowPitch);
+	WRITE_DPR(pSmi, 0x3C, pSmi->ShadowPitch);
+	WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
+    }
 
-	/* #672 */
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
-	}
+    /* #672 */
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    }
 
-	while (num--)
-	{
-		/* Get coordinates of the box to refresh. */
-		srcX   = pbox->x1;
-		srcY   = pbox->y1;
-		width  = pbox->x2 - srcX;
-		height = pbox->y2 - srcY;
-
-		DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", srcX, srcY, width, height));
-
-		if ((width > 0) && (height > 0))
-		{
-			switch (pSmi->rotate)
-			{
-				case SMI_ROTATE_CW:
-					/* 90 degrees CW rotation.  Calculate destination
-					   coordinates:
-
-						*---+
-						|   |       +-----*
-						|   |       |     |  destX = shadowHeight - srcY - 1
-						|   |  -->  |     |  destY = srcX
-						|   |       |     |
-						|   |       +-----+
-						+---+
-					*/
-					destX = pSmi->ShadowHeight - srcY - 1;
-					destY = srcX;
-
-					WaitQueue(4);
-					WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
-					WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
-					WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
-					WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
-							SMI_ROTATE_CW | SMI_START_ENGINE);
-					break;
-
-				case SMI_ROTATE_CCW:
-					/* 90 degrees CCW rotatation.  Calculate destination
-					   coordinates:
-
-						*---+
-						|   |       +-----+
-						|   |       |     |  destX = srcY
-						|   |  -->  |     |  destY = shadowWidth - srcX - 1
-						|   |       |     |
-						|   |       *-----+
-						+---+
-					*/
-					destX = srcY;
-					destY = pSmi->ShadowWidth - srcX - 1;
-
-					WaitQueue(4);
-					WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
-					WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
-					WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
-					WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
-							SMI_ROTATE_CCW | SMI_START_ENGINE);
-					break;
-
-				default:
-					/* No rotation, perform a normal copy. */
-					if (pScrn->bitsPerPixel == 24)
-					{
-						srcX  *= 3;
-						width *= 3;
-
-						if (pSmi->Chipset == SMI_LYNX)
-						{
-							srcY *= 3;
-						}
-					}
-
-					WaitQueue(4);
-					WRITE_DPR(pSmi, 0x00, (srcX << 16)  + srcY);
-					WRITE_DPR(pSmi, 0x04, (srcX << 16)  + srcY);
-					WRITE_DPR(pSmi, 0x08, (width << 16) + height);
-					WRITE_DPR(pSmi, 0x0C, SMI_BITBLT + SMI_START_ENGINE + 0xCC);
-					break;
-			}
+    while (num--) {
+	/* Get coordinates of the box to refresh. */
+	srcX   = pbox->x1;
+	srcY   = pbox->y1;
+	width  = pbox->x2 - srcX;
+	height = pbox->y2 - srcY;
+
+	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", srcX, srcY, width, height));
+
+	if ((width > 0) && (height > 0)) {
+	    switch (pSmi->rotate) {
+	    case SMI_ROTATE_CW:
+		/* 90 degrees CW rotation.  Calculate destination coordinates:
+
+		 *---+
+		 |   |       +-----*
+		 |   |       |     |  destX = shadowHeight - srcY - 1
+		 |   |  -->  |     |  destY = srcX
+		 |   |       |     |
+		 |   |       +-----+
+		 +---+
+		 */
+		destX = pSmi->ShadowHeight - srcY - 1;
+		destY = srcX;
+
+		WaitQueue(4);
+		WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
+		WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
+		WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
+		WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
+					SMI_ROTATE_CW | SMI_START_ENGINE);
+		break;
+	    case SMI_ROTATE_CCW:
+		/* 90 degrees CCW rotatation.  Calculate destination coordinates:
+
+		 *---+
+		 |   |       +-----+
+		 |   |       |     |  destX = srcY
+		 |   |  -->  |     |  destY = shadowWidth - srcX - 1
+		 |   |       |     |
+		 |   |       *-----+
+		 +---+
+		 */
+		destX = srcY;
+		destY = pSmi->ShadowWidth - srcX - 1;
+
+		WaitQueue(4);
+		WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
+		WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
+		WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
+		WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
+					SMI_ROTATE_CCW | SMI_START_ENGINE);
+		break;
+	    default:
+		/* No rotation, perform a normal copy. */
+		if (pScrn->bitsPerPixel == 24) {
+		    srcX  *= 3;
+		    width *= 3;
+
+		    if (pSmi->Chipset == SMI_LYNX) {
+			srcY *= 3;
+		    }
 		}
 
-		pbox++;
+		WaitQueue(4);
+		WRITE_DPR(pSmi, 0x00, (srcX << 16)  + srcY);
+		WRITE_DPR(pSmi, 0x04, (srcX << 16)  + srcY);
+		WRITE_DPR(pSmi, 0x08, (width << 16) + height);
+		WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_BITBLT | SMI_START_ENGINE);
+		break;
+	    }
 	}
 
-	if (pSmi->rotate)
-	{
-		/* If we did a rotation, we need to restore the hardware state here. */
-		WaitIdleEmpty();
-		WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
-		WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
-		WRITE_DPR(pSmi, 0x44, 0);
-	}
+	pbox++;
+    }
+
+    if (pSmi->rotate) {
+	/* If we did a rotation, we need to restore the hardware state here. */
+	WaitIdleEmpty();
+	WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
+	WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
+	WRITE_DPR(pSmi, 0x44, 0);
+    }
 
-	LEAVE_PROC("SMI_RefreshArea");
+    LEAVE_PROC("SMI_RefreshArea");
 }
 
 /* Custom version for the 730 series (Cougar3DR).
@@ -189,155 +176,140 @@ void SMI_RefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
 
 void SMI_RefreshArea730(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int width, height, srcX, srcY, destX, destY;
-	int maxPixels, tempWidth;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int width, height, srcX, srcY, destX, destY;
+    int maxPixels, tempWidth;
 
-	ENTER_PROC("SMI_RefreshArea730");
+    ENTER_PROC("SMI_RefreshArea730");
 
-	/* #671 */
-	if (pSmi->polyLines)
-	{
-		pSmi->polyLines = FALSE;
-		return;
-	}
+    /* #671 */
+    if (pSmi->polyLines) {
+	pSmi->polyLines = FALSE;
+	return;
+    }
 
-	if (pSmi->rotate)
-	{
-		/* IF we need to do rotation, setup the hardware here. */
-		WaitIdleEmpty();
-		WRITE_DPR(pSmi, 0x10, pSmi->ShadowPitch);
-		WRITE_DPR(pSmi, 0x3C, pSmi->ShadowPitch);
-		WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
-	}
+    if (pSmi->rotate) {
+	/* IF we need to do rotation, setup the hardware here. */
+	WaitIdleEmpty();
+	WRITE_DPR(pSmi, 0x10, pSmi->ShadowPitch);
+	WRITE_DPR(pSmi, 0x3C, pSmi->ShadowPitch);
+	WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
+    }
 
-	/* #672 */
-	if (pSmi->ClipTurnedOn)
-	{
-		WaitQueue(1);
-		WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
-		pSmi->ClipTurnedOn = FALSE;
-	}
+    /* #672 */
+    if (pSmi->ClipTurnedOn) {
+	WaitQueue(1);
+	WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
+	pSmi->ClipTurnedOn = FALSE;
+    }
 
-	/* SM731 cannot rotate-blt more than a certain number of pixels
-	   (based on a calculation from the Windows driver source */
-	maxPixels = 1280 / pScrn->bitsPerPixel;
-
-	while (num--)
-	{
-		/* Get coordinates of the box to refresh. */
-		srcX   = pbox->x1;
-		srcY   = pbox->y1;
-		width  = pbox->x2 - srcX;
-		height = pbox->y2 - srcY;
-
-		DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", srcX, srcY, width, height));
-
-		if ((width > 0) && (height > 0))
-		{
-			switch (pSmi->rotate)
-			{
-				case SMI_ROTATE_CW:
-					/* 90 degrees CW rotation.  Calculate destination
-					   coordinates:
-
-						*---+
-						|   |       +-----*
-						|   |       |     |  destX = shadowHeight - srcY - 1
-						|   |  -->  |     |  destY = srcX
-						|   |       |     |
-						|   |       +-----+
-						+---+
-					*/
-					destX = pSmi->ShadowHeight - srcY - 1;
-					destY = srcX;
-
-					for (tempWidth=width; tempWidth>0;)
-					{
-						if (width>maxPixels)
-							width = maxPixels;
-						WaitQueue(4);
-						WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
-						WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
-						WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
-						WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
-								SMI_ROTATE_CW | SMI_START_ENGINE);
-						destY 	  += maxPixels;
-						srcX  	  += maxPixels;
-						tempWidth -= maxPixels;
-						width      = tempWidth;
-					}
-
-					break;
-
-				case SMI_ROTATE_CCW:
-					/* 90 degrees CCW rotatation.  Calculate destination
-					   coordinates:
-
-						*---+
-						|   |       +-----+
-						|   |       |     |  destX = srcY
-						|   |  -->  |     |  destY = shadowWidth - srcX - 1
-						|   |       |     |
-						|   |       *-----+
-						+---+
-					*/
-					destX = srcY;
-					destY = pSmi->ShadowWidth - srcX - 1;
-
-					for (tempWidth=width; tempWidth>0;)
-					{
-						if (width>maxPixels)
-							width = maxPixels;
-						WaitQueue(4);
-						WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
-						WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
-						WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
-						WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
-								SMI_ROTATE_CCW | SMI_START_ENGINE);
-						destY 	  -= maxPixels;
-						srcX  	  += maxPixels;
-						tempWidth -= maxPixels;
-						width      = tempWidth;
-					}
-
-					break;
-
-				default:
-					/* No rotation, perform a normal copy. */
-					if (pScrn->bitsPerPixel == 24)
-					{
-						srcX  *= 3;
-						width *= 3;
-
-						if (pSmi->Chipset == SMI_LYNX)
-						{
-							srcY *= 3;
-						}
-					}
-
-					WaitQueue(4);
-					WRITE_DPR(pSmi, 0x00, (srcX << 16)  + srcY);
-					WRITE_DPR(pSmi, 0x04, (srcX << 16)  + srcY);
-					WRITE_DPR(pSmi, 0x08, (width << 16) + height);
-					WRITE_DPR(pSmi, 0x0C, SMI_BITBLT + SMI_START_ENGINE + 0xCC);
-					break;
-			}
+    /* SM731 cannot rotate-blt more than a certain number of pixels
+       (based on a calculation from the Windows driver source */
+    maxPixels = 1280 / pScrn->bitsPerPixel;
+
+    while (num--) {
+	/* Get coordinates of the box to refresh. */
+	srcX   = pbox->x1;
+	srcY   = pbox->y1;
+	width  = pbox->x2 - srcX;
+	height = pbox->y2 - srcY;
+
+	DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", srcX, srcY, width, height));
+
+	if ((width > 0) && (height > 0)) {
+	    switch (pSmi->rotate) {
+	    case SMI_ROTATE_CW:
+		/* 90 degrees CW rotation.  Calculate destination coordinates:
+
+		 *---+
+		 |   |       +-----*
+		 |   |       |     |  destX = shadowHeight - srcY - 1
+		 |   |  -->  |     |  destY = srcX
+		 |   |       |     |
+		 |   |       +-----+
+		 +---+
+		 */
+		destX = pSmi->ShadowHeight - srcY - 1;
+		destY = srcX;
+
+		for (tempWidth=width; tempWidth > 0;) {
+		    if (width>maxPixels)
+			width = maxPixels;
+		    WaitQueue(4);
+		    WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
+		    WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
+		    WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
+		    WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
+					SMI_ROTATE_CW | SMI_START_ENGINE);
+		    destY   += maxPixels;
+		    srcX    += maxPixels;
+		    tempWidth -= maxPixels;
+		    width      = tempWidth;
 		}
 
-		pbox++;
-	}
+		break;
+	    case SMI_ROTATE_CCW:
+		/* 90 degrees CCW rotatation.  Calculate destination coordinates:
+
+		 *---+
+		 |   |       +-----+
+		 |   |       |     |  destX = srcY
+		 |   |  -->  |     |  destY = shadowWidth - srcX - 1
+		 |   |       |     |
+		 |   |       *-----+
+		 +---+
+		 */
+		destX = srcY;
+		destY = pSmi->ShadowWidth - srcX - 1;
+
+		for (tempWidth=width; tempWidth > 0;) {
+		    if (width>maxPixels)
+			width = maxPixels;
+		    WaitQueue(4);
+		    WRITE_DPR(pSmi, 0x00, (srcX << 16)   + srcY);
+		    WRITE_DPR(pSmi, 0x04, (destX << 16)  + destY);
+		    WRITE_DPR(pSmi, 0x08, (width << 16)  + height);
+		    WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_ROTATE_BLT |
+					SMI_ROTATE_CCW | SMI_START_ENGINE);
+		    destY   -= maxPixels;
+		    srcX    += maxPixels;
+		    tempWidth -= maxPixels;
+		    width      = tempWidth;
+		}
+
+		break;
+	    default:
+		/* No rotation, perform a normal copy. */
+		if (pScrn->bitsPerPixel == 24) {
+		    srcX  *= 3;
+		    width *= 3;
 
-	if (pSmi->rotate)
-	{
-		/* If we did a rotation, we need to restore the hardware state here. */
-		WaitIdleEmpty();
-		WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
-		WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
-		WRITE_DPR(pSmi, 0x44, 0);
+		    if (pSmi->Chipset == SMI_LYNX) {
+			srcY *= 3;
+		    }
+		}
+
+		WaitQueue(4);
+		WRITE_DPR(pSmi, 0x00, (srcX << 16)  + srcY);
+		WRITE_DPR(pSmi, 0x04, (srcX << 16)  + srcY);
+		WRITE_DPR(pSmi, 0x08, (width << 16) + height);
+		WRITE_DPR(pSmi, 0x0C, 0xCC | SMI_BITBLT | SMI_START_ENGINE);
+		break;
+	    }
 	}
 
-	LEAVE_PROC("SMI_RefreshArea730");
+	pbox++;
+    }
+
+    if (pSmi->rotate) {
+	/* If we did a rotation, we need to restore the hardware state here. */
+	WaitIdleEmpty();
+	WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
+	WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
+	WRITE_DPR(pSmi, 0x44, 0);
+    }
+
+    LEAVE_PROC("SMI_RefreshArea730");
 }
 
 /******************************************************************************\
@@ -345,8 +317,8 @@ void SMI_RefreshArea730(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
 |*=============================================================================
 |*
 |*  PARAMETERS:		index	Index of current screen.
-|*					x		X location of pointer.
-|*					y		Y location of pointer.
+|*			x	X location of pointer.
+|*			y	Y location of pointer.
 |*
 |*  DESCRIPTION:	Adjust the pointer location if we are in rotation mode.
 |*
@@ -359,27 +331,25 @@ void SMI_PointerMoved(int index, int x, int y)
     SMIPtr pSmi = SMIPTR(pScrn);
     int newX, newY;
 
-	switch (pSmi->rotate)
-	{
-		case SMI_ROTATE_CW:
-			/* 90 degrees CW rotation. */
-			newX = pScrn->pScreen->height - y - 1;
-			newY = x;
-			break;
-
-		case SMI_ROTATE_CCW:
-			/* 90 degrees CCW rotation. */
-			newX = y;
-			newY = pScrn->pScreen->width - x - 1;
-			break;
-
-		default:
-			/* No rotation. */
-			newX = x;
-			newY = y;
-			break;
+    switch (pSmi->rotate) {
+    case SMI_ROTATE_CW:
+	/* 90 degrees CW rotation. */
+	newX = pScrn->pScreen->height - y - 1;
+	newY = x;
+	break;
+    case SMI_ROTATE_CCW:
+	/* 90 degrees CCW rotation. */
+	newX = y;
+	newY = pScrn->pScreen->width - x - 1;
+	break;
+    default:
+	/* No rotation. */
+	newX = x;
+	newY = y;
+	break;
     }
 
-	/* Pass adjusted pointer coordinates original PointerMoved function. */
+    /* Pass adjusted pointer coordinates original PointerMoved function. */
     (*pSmi->PointerMoved)(index, newX, newY);
 }
+
diff --git a/src/smi_video.c b/src/smi_video.c
index 1166c03..db19ffd 100644
--- a/src/smi_video.c
+++ b/src/smi_video.c
@@ -237,9 +237,9 @@ static VideoNormDataRec VideoNorms[] =
 
 static XF86VideoFormatRec SMI_VideoFormats[] =
 {
-	{ 15, TrueColor },					/* depth, class				*/
-	{ 16, TrueColor },					/* depth, class				*/
-	{ 24, TrueColor },					/* depth, class				*/
+    { 15, TrueColor },	/* depth, class				*/
+    { 16, TrueColor },	/* depth, class				*/
+    { 24, TrueColor },	/* depth, class				*/
 };
 
 
@@ -280,85 +280,85 @@ static XF86AttributeRec SMI_VideoAttributes[2] = {
 /**************************************************************************/
 static XF86ImageRec SMI_VideoImages[] =
 {
-	XVIMAGE_YUY2,
-	XVIMAGE_YV12,
-	XVIMAGE_I420,
-	{
-		FOURCC_RV15,					/* id						*/
-		XvRGB,							/* type						*/
-		LSBFirst,						/* byte_order				*/
-		{ 'R', 'V' ,'1', '5',
-		  0x00, '5',  0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00 },		/* guid						*/
-		16,								/* bits_per_pixel			*/
-		XvPacked,						/* format					*/
-		1,								/* num_planes				*/
-		15,								/* depth					*/
-		0x001F, 0x03E0, 0x7C00,			/* red_mask, green, blue	*/
-		0, 0, 0,						/* y_sample_bits, u, v		*/
-		0, 0, 0,						/* horz_y_period, u, v		*/
-		0, 0, 0,						/* vert_y_period, u, v		*/
-		{ 'R', 'V', 'B' },				/* component_order			*/
-		XvTopToBottom					/* scaline_order			*/
-	},
-	{
-		FOURCC_RV16,					/* id						*/
-		XvRGB,							/* type						*/
-		LSBFirst,						/* byte_order				*/
-		{ 'R', 'V' ,'1', '6',
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00 },		/* guid						*/
-		16,								/* bits_per_pixel			*/
-		XvPacked,						/* format					*/
-		1,								/* num_planes				*/
-		16,								/* depth					*/
-		0x001F, 0x07E0, 0xF800,			/* red_mask, green, blue	*/
-		0, 0, 0,						/* y_sample_bits, u, v		*/
-		0, 0, 0,						/* horz_y_period, u, v		*/
-		0, 0, 0,						/* vert_y_period, u, v		*/
-		{ 'R', 'V', 'B' },				/* component_order			*/
-		XvTopToBottom					/* scaline_order			*/
-	},
-	{
-		FOURCC_RV24,					/* id						*/
-		XvRGB,							/* type						*/
-		LSBFirst,						/* byte_order				*/
-		{ 'R', 'V' ,'2', '4',
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00 },		/* guid						*/
-		24,								/* bits_per_pixel			*/
-		XvPacked,						/* format					*/
-		1,								/* num_planes				*/
-		24,								/* depth					*/
-		0x0000FF, 0x00FF00, 0xFF0000,	/* red_mask, green, blue	*/
-		0, 0, 0,						/* y_sample_bits, u, v		*/
-		0, 0, 0,						/* horz_y_period, u, v		*/
-		0, 0, 0,						/* vert_y_period, u, v		*/
-		{ 'R', 'V', 'B' },				/* component_order			*/
-		XvTopToBottom					/* scaline_order			*/
-	},
-	{
-		FOURCC_RV32,					/* id						*/
-		XvRGB,							/* type						*/
-		LSBFirst,						/* byte_order				*/
-		{ 'R', 'V' ,'3', '2',
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00,
-		  0x00, 0x00, 0x00, 0x00 },		/* guid						*/
-		32,								/* bits_per_pixel			*/
-		XvPacked,						/* format					*/
-		1,								/* num_planes				*/
-		24,								/* depth					*/
-		0x0000FF, 0x00FF00, 0xFF0000,	/* red_mask, green, blue	*/
-		0, 0, 0,						/* y_sample_bits, u, v		*/
-		0, 0, 0,						/* horz_y_period, u, v		*/
-		0, 0, 0,						/* vert_y_period, u, v		*/
-		{ 'R', 'V', 'B' },				/* component_order			*/
-		XvTopToBottom					/* scaline_order			*/
-	},
+    XVIMAGE_YUY2,
+    XVIMAGE_YV12,
+    XVIMAGE_I420,
+    {
+	FOURCC_RV15,			/* id				*/
+	XvRGB,				/* type				*/
+	LSBFirst,			/* byte_order			*/
+	{ 'R', 'V' ,'1', '5',
+	  0x00, '5',  0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00 },	/* guid				*/
+	16,				/* bits_per_pixel		*/
+	XvPacked,			/* format			*/
+	1,				/* num_planes			*/
+	15,				/* depth			*/
+	0x001F, 0x03E0, 0x7C00,		/* red_mask, green, blue	*/
+	0, 0, 0,			/* y_sample_bits, u, v		*/
+	0, 0, 0,			/* horz_y_period, u, v		*/
+	0, 0, 0,			/* vert_y_period, u, v		*/
+	{ 'R', 'V', 'B' },		/* component_order		*/
+	XvTopToBottom			/* scaline_order		*/
+    },
+    {
+	FOURCC_RV16,			/* id				*/
+	XvRGB,				/* type				*/
+	LSBFirst,			/* byte_order			*/
+	{ 'R', 'V' ,'1', '6',
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00 },	/* guid				*/
+	16,				/* bits_per_pixel		*/
+	XvPacked,			/* format			*/
+	1,				/* num_planes			*/
+	16,				/* depth			*/
+	0x001F, 0x07E0, 0xF800,		/* red_mask, green, blue	*/
+	0, 0, 0,			/* y_sample_bits, u, v		*/
+	0, 0, 0,			/* horz_y_period, u, v		*/
+	0, 0, 0,			/* vert_y_period, u, v		*/
+	{ 'R', 'V', 'B' },		/* component_order		*/
+	XvTopToBottom			/* scaline_order		*/
+    },
+    {
+	FOURCC_RV24,			/* id				*/
+	XvRGB,				/* type				*/
+	LSBFirst,			/* byte_order			*/
+	{ 'R', 'V' ,'2', '4',
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00 },	/* guid				*/
+	24,				/* bits_per_pixel		*/
+	XvPacked,			/* format			*/
+	1,				/* num_planes			*/
+	24,				/* depth			*/
+	0x0000FF, 0x00FF00, 0xFF0000,	/* red_mask, green, blue	*/
+	0, 0, 0,			/* y_sample_bits, u, v		*/
+	0, 0, 0,			/* horz_y_period, u, v		*/
+	0, 0, 0,			/* vert_y_period, u, v		*/
+	{ 'R', 'V', 'B' },		/* component_order			*/
+	XvTopToBottom			/* scaline_order			*/
+    },
+    {
+	FOURCC_RV32,			/* id				*/
+	XvRGB,				/* type				*/
+	LSBFirst,			/* byte_order			*/
+	{ 'R', 'V' ,'3', '2',
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00 },	/* guid				*/
+	32,				/* bits_per_pixel		*/
+	XvPacked,			/* format			*/
+	1,				/* num_planes			*/
+	24,				/* depth			*/
+	0x0000FF, 0x00FF00, 0xFF0000,	/* red_mask, green, blue	*/
+	0, 0, 0,			/* y_sample_bits, u, v		*/
+	0, 0, 0,			/* horz_y_period, u, v		*/
+	0, 0, 0,			/* vert_y_period, u, v		*/
+	{ 'R', 'V', 'B' },		/* component_order			*/
+	XvTopToBottom			/* scaline_order			*/
+    },
 };
 
 
@@ -645,19 +645,14 @@ SMI_InitVideo(ScreenPtr pScreen)
         SMI_InitOffscreenImages(pScreen);
     }
 
-    if (newAdaptor != NULL)
-    {
-        if (numAdaptors == 0)
-        {
+    if (newAdaptor != NULL) {
+        if (numAdaptors == 0) {
             numAdaptors = 1;
             ptrAdaptors = &newAdaptor;
-        }
-        else
-        {
+        } else {
             newAdaptors = xalloc((numAdaptors + 1) *
                     sizeof(XF86VideoAdaptorPtr*));
-            if (newAdaptors != NULL)
-            {
+            if (newAdaptors != NULL) {
                 memcpy(newAdaptors, ptrAdaptors,
                         numAdaptors * sizeof(XF86VideoAdaptorPtr));
                 newAdaptors[numAdaptors++] = newAdaptor;
@@ -666,14 +661,12 @@ SMI_InitVideo(ScreenPtr pScreen)
         }
     }
 
-    if (numAdaptors != 0)
-    {
-      DEBUG((VERBLEV, "ScreenInit %i\n",numAdaptors));
+    if (numAdaptors != 0) {
+        DEBUG((VERBLEV, "ScreenInit %i\n",numAdaptors));
         xf86XVScreenInit(pScreen, ptrAdaptors, numAdaptors);
     }
 
-    if (newAdaptors != NULL)
-    {
+    if (newAdaptors != NULL) {
         xfree(newAdaptors);
     }
 
@@ -719,8 +712,7 @@ SetAttr(ScrnInfoPtr pScrn, int i, int value)
 	SetKeyReg(pSmi, 0x5C, 0xEDEDED | (my_value << 24));
     } else if (pPort->I2CDev.SlaveAddr == SAA7110) {
 	return SetAttrSAA7110(pScrn, i, value);
-    }
-    else if (pPort->I2CDev.SlaveAddr == SAA7111) {
+    } else if (pPort->I2CDev.SlaveAddr == SAA7111) {
 	return SetAttrSAA7111(pScrn, i, value);
     }
 #if 0
@@ -777,16 +769,14 @@ SetAttrSAA7111(ScrnInfoPtr pScrn, int i, int value)
 				 ENTRIES(SAA7111CompositeChannelSelect[channel]) / 2)) {
 		return XvBadAlloc;
 	    }
-	}
-	else {
+	} else {
 	    if (!xf86I2CWriteVec(&(pPort->I2CDev),
 				 SAA7111SVideoChannelSelect[channel],
 				 ENTRIES(SAA7111SVideoChannelSelect[channel]) / 2)) {
 		return XvBadAlloc;
 	    }
 	}
-    }
-    else if (i >= XV_CAPTURE_BRIGHTNESS && i <= XV_HUE) {
+    } else if (i >= XV_CAPTURE_BRIGHTNESS && i <= XV_HUE) {
 	int slave_adr = 0;
 
 	switch (i) {
@@ -816,8 +806,7 @@ SetAttrSAA7111(ScrnInfoPtr pScrn, int i, int value)
 	}
 	if (!xf86I2CWriteByte(&(pPort->I2CDev), slave_adr, (value & 0xff)))
 	    return XvBadAlloc;
-    }
-    else {
+    } else {
 	return BadMatch;
     }
 
@@ -838,45 +827,42 @@ SetAttrSAA7111(ScrnInfoPtr pScrn, int i, int value)
 
 
 /******************************************************************************\
-**																			  **
-**						 V I D E O   M A N A G E M E N T					  **
-**																			  **
+**									      **
+**	V I D E O   M A N A G E M E N T					      **
+**									      **
 \******************************************************************************/
 
 static XF86VideoAdaptorPtr
-SMI_SetupVideo(
-	ScreenPtr	pScreen
-)
+SMI_SetupVideo(ScreenPtr pScreen)
 {
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	SMI_PortPtr smiPortPtr;
-	XF86VideoAdaptorPtr ptrAdaptor;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    SMI_PortPtr smiPortPtr;
+    XF86VideoAdaptorPtr ptrAdaptor;
 
-	ENTER_PROC("SMI_SetupVideo");
+    ENTER_PROC("SMI_SetupVideo");
 
-	ptrAdaptor = xcalloc(1, sizeof(XF86VideoAdaptorRec) +
-			sizeof(DevUnion) + sizeof(SMI_PortRec));
-	if (ptrAdaptor == NULL)
-	{
-		LEAVE_PROC("SMI_SetupVideo");
-		return(NULL);
-	}
+    ptrAdaptor = xcalloc(1, sizeof(XF86VideoAdaptorRec) +
+		 sizeof(DevUnion) + sizeof(SMI_PortRec));
+    if (ptrAdaptor == NULL) {
+	LEAVE_PROC("SMI_SetupVideo");
+	return NULL;
+    }
 
-	ptrAdaptor->type = XvInputMask
+    ptrAdaptor->type = XvInputMask
 #if SMI_USE_CAPTURE
-					 | XvOutputMask
-					 | XvVideoMask
+		     | XvOutputMask
+		     | XvVideoMask
 #endif
-					 | XvImageMask
-					 | XvWindowMask
-					 ;
+		     | XvImageMask
+		     | XvWindowMask
+		     ;
 
-	ptrAdaptor->flags = VIDEO_OVERLAID_IMAGES
-					  | VIDEO_CLIP_TO_VIEWPORT
-					  ;
+    ptrAdaptor->flags = VIDEO_OVERLAID_IMAGES
+		      | VIDEO_CLIP_TO_VIEWPORT
+		      ;
 
-	ptrAdaptor->name = "Silicon Motion Lynx Series Video Engine";
+    ptrAdaptor->name = "Silicon Motion Lynx Series Video Engine";
 
     ptrAdaptor->nPorts = 1;
     ptrAdaptor->pPortPrivates = (DevUnion*) &ptrAdaptor[1];
@@ -896,39 +882,39 @@ SMI_SetupVideo(
 	}
 #endif
 
-	ptrAdaptor->nFormats = nElems(SMI_VideoFormats);
-	ptrAdaptor->pFormats = SMI_VideoFormats;
+    ptrAdaptor->nFormats = nElems(SMI_VideoFormats);
+    ptrAdaptor->pFormats = SMI_VideoFormats;
 
-	ptrAdaptor->nAttributes = nElems(SMI_VideoAttributes);
-	ptrAdaptor->pAttributes = SMI_VideoAttributes;
+    ptrAdaptor->nAttributes = nElems(SMI_VideoAttributes);
+    ptrAdaptor->pAttributes = SMI_VideoAttributes;
 
-	ptrAdaptor->nImages = nElems(SMI_VideoImages);
-	ptrAdaptor->pImages = SMI_VideoImages;
+    ptrAdaptor->nImages = nElems(SMI_VideoImages);
+    ptrAdaptor->pImages = SMI_VideoImages;
 
 #if SMI_USE_CAPTURE
-	if (pSmi->Chipset == SMI_COUGAR3DR)
-		ptrAdaptor->PutVideo = NULL;
-	else
-		ptrAdaptor->PutVideo = SMI_PutVideo;
-	ptrAdaptor->PutStill = NULL;
+    if (pSmi->Chipset == SMI_COUGAR3DR)
+	ptrAdaptor->PutVideo = NULL;
+    else
+	ptrAdaptor->PutVideo = SMI_PutVideo;
+    ptrAdaptor->PutStill = NULL;
     ptrAdaptor->GetVideo = NULL;
-	ptrAdaptor->GetStill = NULL;
+    ptrAdaptor->GetStill = NULL;
 #else
-	ptrAdaptor->PutVideo = NULL;
-	ptrAdaptor->PutStill = NULL;
-	ptrAdaptor->GetVideo = NULL;
-	ptrAdaptor->GetStill = NULL;
+    ptrAdaptor->PutVideo = NULL;
+    ptrAdaptor->PutStill = NULL;
+    ptrAdaptor->GetVideo = NULL;
+    ptrAdaptor->GetStill = NULL;
 #endif
-	ptrAdaptor->StopVideo = SMI_StopVideo;
-	ptrAdaptor->SetPortAttribute = SMI_SetPortAttribute;
-	ptrAdaptor->GetPortAttribute = SMI_GetPortAttribute;
-	ptrAdaptor->QueryBestSize = SMI_QueryBestSize;
-	ptrAdaptor->PutImage = SMI_PutImage;
-	ptrAdaptor->QueryImageAttributes = SMI_QueryImageAttributes;
+    ptrAdaptor->StopVideo = SMI_StopVideo;
+    ptrAdaptor->SetPortAttribute = SMI_SetPortAttribute;
+    ptrAdaptor->GetPortAttribute = SMI_GetPortAttribute;
+    ptrAdaptor->QueryBestSize = SMI_QueryBestSize;
+    ptrAdaptor->PutImage = SMI_PutImage;
+    ptrAdaptor->QueryImageAttributes = SMI_QueryImageAttributes;
 
     smiPortPtr->Attribute[XV_COLORKEY] = pSmi->videoKey;
     smiPortPtr->Attribute[XV_INTERLACED] = pSmi->interlaced;
-	smiPortPtr->videoStatus = 0;
+    smiPortPtr->videoStatus = 0;
 
 #if 0
     /* aaa does not work ? */
@@ -945,11 +931,9 @@ SMI_SetupVideo(
     smiPortPtr->I2CDev.pI2CBus = pSmi->I2C;
 
     
-    if (xf86I2CDevInit(&(smiPortPtr->I2CDev)))
-    {
+    if (xf86I2CDevInit(&(smiPortPtr->I2CDev))) {
 	
-	if (xf86I2CWriteVec(&(smiPortPtr->I2CDev), 	SAA7111InitData, 
-			    ENTRIES(SAA7111InitData) / 2)) {
+	if (xf86I2CWriteVec(&(smiPortPtr->I2CDev), SAA7111InitData, ENTRIES(SAA7111InitData) / 2)) {
 	    xvEncoding   = MAKE_ATOM(XV_ENCODING_NAME);
 	    xvHue        = MAKE_ATOM(XV_HUE_NAME);
 	    xvSaturation = MAKE_ATOM(XV_SATURATION_NAME);
@@ -981,20 +965,18 @@ SMI_SetupVideo(
     
     SMI_ResetVideo(pScrn);
     LEAVE_PROC("SMI_SetupVideo");
-    return(ptrAdaptor);
+    return ptrAdaptor;
 }
 
 
 static void
-SMI_ResetVideo(
-	ScrnInfoPtr	pScrn
-)
+SMI_ResetVideo(ScrnInfoPtr pScrn)
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
     SMI_PortPtr pPort = (SMI_PortPtr) pSmi->ptrAdaptor->pPortPrivates[0].ptr;
-	int r, g, b;
+    int r, g, b;
 
-	ENTER_PROC("SMI_ResetVideo");
+    ENTER_PROC("SMI_ResetVideo");
 
     SetAttr(pScrn, XV_ENCODING, 0);     /* Encoding = pal-composite-0 */
     SetAttr(pScrn, XV_BRIGHTNESS, 128); /* Brightness = 128 (CCIR level) */
@@ -1003,31 +985,28 @@ SMI_ResetVideo(
     SetAttr(pScrn, XV_SATURATION, 64);  /* Color saturation = 64 (CCIR level) */
     SetAttr(pScrn, XV_HUE, 0);          /* Hue = 0 */
 
-	switch (pScrn->depth)
-	{
-		case 8:
-            SetKeyReg(pSmi, FPR04, pPort->Attribute[XV_COLORKEY] & 0x00FF);
-			SetKeyReg(pSmi, FPR08, 0);
-			break;
-
-		case 15:
-		case 16:
-			SetKeyReg(pSmi, FPR04, pPort->Attribute[XV_COLORKEY] & 0xFFFF);
-			SetKeyReg(pSmi, FPR08, 0);
-			break;
-
-		default:
-            r = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.red) >> pScrn->offset.red;
-            g = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.green) >> pScrn->offset.green;
-            b = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.blue) >> pScrn->offset.blue;
-			SetKeyReg(pSmi, FPR04, ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3));
-			SetKeyReg(pSmi, FPR08, 0);
-			break;
-	}
+    switch (pScrn->depth) {
+    case 8:
+	SetKeyReg(pSmi, FPR04, pPort->Attribute[XV_COLORKEY] & 0x00FF);
+	SetKeyReg(pSmi, FPR08, 0);
+	break;
+    case 15:
+    case 16:
+	SetKeyReg(pSmi, FPR04, pPort->Attribute[XV_COLORKEY] & 0xFFFF);
+	SetKeyReg(pSmi, FPR08, 0);
+	break;
+    default:
+        r = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.red) >> pScrn->offset.red;
+        g = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.green) >> pScrn->offset.green;
+        b = (pPort->Attribute[XV_COLORKEY] & pScrn->mask.blue) >> pScrn->offset.blue;
+	SetKeyReg(pSmi, FPR04, ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3));
+	SetKeyReg(pSmi, FPR08, 0);
+	break;
+    }
 
-	SetKeyReg(pSmi, FPR5C, 0xEDEDED | (pPort->Attribute[XV_BRIGHTNESS] << 24));
+    SetKeyReg(pSmi, FPR5C, 0xEDEDED | (pPort->Attribute[XV_BRIGHTNESS] << 24));
 
-	LEAVE_PROC("SMI_ResetVideo");
+    LEAVE_PROC("SMI_ResetVideo");
 }
 
 
@@ -1049,15 +1028,15 @@ SMI_PutVideo(
 )
 {
     SMI_PortPtr pPort = (SMI_PortPtr) data;
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD32 vid_pitch, vid_address;
-	CARD32 vpr00, cpr00;
-	int xscale, yscale;
-	BoxRec dstBox;
-	INT32 x1, y1, x2, y2;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD32 vid_pitch, vid_address;
+    CARD32 vpr00, cpr00;
+    int xscale, yscale;
+    BoxRec dstBox;
+    INT32 x1, y1, x2, y2;
     int norm;
-	int areaHeight, width, height, fbPitch;
-	int top, left;
+    int areaHeight, width, height, fbPitch;
+    int top, left;
 
     ENTER_PROC("SMI_PutVideo");
 
@@ -1079,42 +1058,39 @@ SMI_PutVideo(
 	   "vid_w=%d vid_h=%d drw_w=%d drw_h=%d\n",
 	   vid_x, vid_y, drw_x, drw_y, vid_w, vid_h, drw_w, drw_h));
 
-	x1 = vid_x;
-	y1 = vid_y;
-	x2 = vid_x + vid_w;
-	y2 = vid_y + vid_h;
+    x1 = vid_x;
+    y1 = vid_y;
+    x2 = vid_x + vid_w;
+    y2 = vid_y + vid_h;
 
-	width = vid_w;
-	height = vid_h;
+    width = vid_w;
+    height = vid_h;
 
-	dstBox.x1 = drw_x;
-	dstBox.y1 = drw_y;
-	dstBox.x2 = drw_x + drw_w;
-	dstBox.y2 = drw_y + drw_h;
+    dstBox.x1 = drw_x;
+    dstBox.y1 = drw_y;
+    dstBox.x2 = drw_x + drw_w;
+    dstBox.y2 = drw_y + drw_h;
 
 #if 1
-	if (!SMI_ClipVideo(pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes, width,
-			height))
+    if (!SMI_ClipVideo(pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes, width, height)) {
 #else
-    if (!xf86XVClipVideoHelper(&dstBox, &x1, &y1, &x2, &y2, clipBoxes, width,
-            height))
+    if (!xf86XVClipVideoHelper(&dstBox, &x1, &y1, &x2, &y2, clipBoxes, width, height)) {
 #endif
-	{
         LEAVE_PROC("SMI_PutVideo");
-		return(Success);
-	}
+	return Success;
+    }
 
     DEBUG((VERBLEV, "Clip: x1=%d y1=%d x2=%d y2=%d\n",  x1 >> 16, y1 >> 16, x2 >> 16, y2 >> 16));
 
-	dstBox.x1 -= pScrn->frameX0;
-	dstBox.y1 -= pScrn->frameY0;
-	dstBox.x2 -= pScrn->frameX0;
-	dstBox.y2 -= pScrn->frameY0;
+    dstBox.x1 -= pScrn->frameX0;
+    dstBox.y1 -= pScrn->frameY0;
+    dstBox.x2 -= pScrn->frameX0;
+    dstBox.y2 -= pScrn->frameY0;
 
-	vid_pitch = (vid_w * 2 + 7) & ~7;
+    vid_pitch = (vid_w * 2 + 7) & ~7;
 
-	vpr00 = READ_VPR(pSmi, 0x00) & ~0x0FF000FF;
-	cpr00 = READ_CPR(pSmi, 0x00) & ~0x000FFF00;
+    vpr00 = READ_VPR(pSmi, 0x00) & ~0x0FF000FF;
+    cpr00 = READ_CPR(pSmi, 0x00) & ~0x000FFF00;
 
     /* vpr00:
        Bit 2..0   = 6: Video Window I Format                    = YUV4:2:2
@@ -1141,8 +1117,7 @@ SMI_PutVideo(
 	  Bit 24     = 0: Select Video Window I Source Addr        = 0
 	*/
 	vpr00 |= 0x0010000E;
-    }
-    else {
+    } else {
 	/*
 	  Bit 21     = 10: Vertical Interpolation                   = enabled
 	  Bit 24     = 1: Select Video Window I Source Addr        = 1
@@ -1172,8 +1147,7 @@ SMI_PutVideo(
 	  Bit 13..11 = 0: Frame Skip Enable                     = no skip
 	*/
 	cpr00 |= 0x01000601;
-    }
-    else {
+    } else {
 	/*
 	  Bit 9      = 0: Double Buffer Enable                  = disabled
 	  Bit 10     = 0: Interlace Data Capture                = disabled
@@ -1182,113 +1156,85 @@ SMI_PutVideo(
 	cpr00 |= 0x01000801;
     }
 
-	if (pSmi->ByteSwap)
-		cpr00 |= 0x00004000;
+    if (pSmi->ByteSwap)
+	cpr00 |= 0x00004000;
 
-	fbPitch = pSmi->Stride;
-	if (pSmi->Bpp != 3)
-	{
-		fbPitch *= pSmi->Bpp;
-	}
+    fbPitch = pSmi->Stride;
+    if (pSmi->Bpp != 3) {
+	fbPitch *= pSmi->Bpp;
+    }
 
-	if (vid_w <= drw_w)
-	{
-		xscale = (256 * vid_w / drw_w) & 0xFF;
-	}
-	else if (vid_w / 2 <= drw_w)
-	{
-		xscale = (128 * vid_w / drw_w) & 0xFF;
-		width /= 2;
-		vid_pitch /= 2;
-		cpr00 |= 0x00010000;
-	}
-	else if (vid_w / 4 <= drw_w)
-	{
-		xscale = (64 * vid_w / drw_w) & 0xFF;
-		width /= 4;
-		vid_pitch /= 4;
-		cpr00 |= 0x00020000;
-	}
-	else
-	{
-		xscale = 0;
-		width /= 4;
-		vid_pitch /= 4;
-		cpr00 |= 0x00020000;
-	}
+    if (vid_w <= drw_w) {
+	xscale = (256 * vid_w / drw_w) & 0xFF;
+    } else if (vid_w / 2 <= drw_w) {
+	xscale = (128 * vid_w / drw_w) & 0xFF;
+	width /= 2;
+	vid_pitch /= 2;
+	cpr00 |= 0x00010000;
+    } else if (vid_w / 4 <= drw_w) {
+	xscale = (64 * vid_w / drw_w) & 0xFF;
+	width /= 4;
+	vid_pitch /= 4;
+	cpr00 |= 0x00020000;
+    } else {
+	xscale = 0;
+	width /= 4;
+	vid_pitch /= 4;
+	cpr00 |= 0x00020000;
+    }
 
-	if (vid_h <= drw_h)
-	{
-		yscale = (256 * vid_h / drw_h) & 0xFF;
-	}
-	else if (vid_h / 2 <= drw_h)
-	{
-		yscale = (128 * vid_h / drw_h) & 0xFF;
-		height /= 2;
-		cpr00 |= 0x00040000;
-	}
-	else if (vid_h / 4 <= drw_h)
-	{
-		yscale = (64 * vid_h / drw_h) & 0xFF;
-		height /= 4;
-		cpr00 |= 0x00080000;
-	}
-	else
-	{
-		yscale = 0;
-		height /= 4;
-		cpr00 |= 0x00080000;
-	}
+    if (vid_h <= drw_h) {
+	yscale = (256 * vid_h / drw_h) & 0xFF;
+    } else if (vid_h / 2 <= drw_h) {
+	yscale = (128 * vid_h / drw_h) & 0xFF;
+	height /= 2;
+	cpr00 |= 0x00040000;
+    } else if (vid_h / 4 <= drw_h) {
+	yscale = (64 * vid_h / drw_h) & 0xFF;
+	height /= 4;
+	cpr00 |= 0x00080000;
+    } else {
+	yscale = 0;
+	height /= 4;
+	cpr00 |= 0x00080000;
+    }
 
-	do
-	{
-		areaHeight = (vid_pitch * height + fbPitch - 1) / fbPitch;
+    do {
+	areaHeight = (vid_pitch * height + fbPitch - 1) / fbPitch;
 	DEBUG((VERBLEV, "SMI_AllocateMemory: vid_pitch=%d height=%d fbPitch=%d areaHeight=%d\n",
 	       vid_pitch, height, fbPitch, areaHeight));
         pPort->area = SMI_AllocateMemory(pScrn, pPort->area, areaHeight);
-        if (pPort->area == NULL)
-		{
-			if ((cpr00 & 0x000C0000) == 0)
-			{
-				/* height -> 1/2 height */
-				yscale = (128 * vid_h / drw_h) & 0xFF;
-				height = vid_h / 2;
-				cpr00 |= 0x00040000;
-			}
-			else if (cpr00 & 0x00040000)
-			{
-				/* 1/2 height -> 1/4 height */
-				yscale = (64 * vid_h / drw_h) & 0xFF;
-				height = vid_h / 4;
-				cpr00 ^= 0x000C0000;
-			}
-			else
-			{
-				/* 1/4 height */
-				if ((cpr00 & 0x00030000) == 0)
-				{
-					/* width -> 1/2 width */
-					xscale = (128 * vid_w / drw_w) & 0xFF;
-					width = vid_w / 2;
-					cpr00 |= 0x00010000;
-				}
-				else if (cpr00 & 0x00010000)
-				{
-					/* 1/2 width -> 1/4 width */
-					xscale = (64 * vid_w / drw_w) & 0xFF;
-					width = vid_w / 4;
-					cpr00 ^= 0x00030000;
-				}
-				else
-				{
+        if (pPort->area == NULL) {
+	    if ((cpr00 & 0x000C0000) == 0) {
+		/* height -> 1/2 height */
+		yscale = (128 * vid_h / drw_h) & 0xFF;
+		height = vid_h / 2;
+		cpr00 |= 0x00040000;
+	    } else if (cpr00 & 0x00040000) {
+		/* 1/2 height -> 1/4 height */
+		yscale = (64 * vid_h / drw_h) & 0xFF;
+		height = vid_h / 4;
+		cpr00 ^= 0x000C0000;
+	    } else {
+		/* 1/4 height */
+		if ((cpr00 & 0x00030000) == 0) {
+		    /* width -> 1/2 width */
+		    xscale = (128 * vid_w / drw_w) & 0xFF;
+		    width = vid_w / 2;
+		    cpr00 |= 0x00010000;
+		} else if (cpr00 & 0x00010000) {
+		    /* 1/2 width -> 1/4 width */
+		    xscale = (64 * vid_w / drw_w) & 0xFF;
+		    width = vid_w / 4;
+		    cpr00 ^= 0x00030000;
+		} else {
 		    DEBUG((VERBLEV, "allocate error\n"));
                     LEAVE_PROC("SMI_PutVideo");
-					return(BadAlloc);
-				}
-			}
+		    return BadAlloc;
 		}
+	    }
 	}
-    while (pPort->area == NULL);
+    } while (pPort->area == NULL);
 
     DEBUG((VERBLEV, "xscale==%d yscale=%d width=%d height=%d\n",
 	   xscale, yscale, width, height));
@@ -1309,26 +1255,26 @@ SMI_PutVideo(
 	DEBUG((VERBLEV, "FillKey\n"));
 	xf86XVFillKeyHelper(pScrn->pScreen, pPort->Attribute[XV_COLORKEY], clipBoxes);
 
-	}
+    }
 
-	left = x1 >> 16;
-	top = y1 >> 16;
-	width = (x2 - x1) >> 16;
-	height = (y2 - y1) >> 16;
+    left = x1 >> 16;
+    top = y1 >> 16;
+    width = (x2 - x1) >> 16;
+    height = (y2 - y1) >> 16;
 
-	OUT_SEQ(pSmi, 0x21, IN_SEQ(pSmi, 0x21) & ~0x04);
-	WRITE_VPR(pSmi, 0x54, READ_VPR(pSmi, 0x54) | 0x00200000);
+    OUT_SEQ(pSmi, 0x21, IN_SEQ(pSmi, 0x21) & ~0x04);
+    WRITE_VPR(pSmi, 0x54, READ_VPR(pSmi, 0x54) | 0x00200000);
 #if 0
 	SMI_WaitForSync(pScrn);
 #endif
     /* Video Window I Left and Top Boundaries */
-	WRITE_VPR(pSmi, 0x14, dstBox.x1 + (dstBox.y1 << 16));
+    WRITE_VPR(pSmi, 0x14, dstBox.x1 + (dstBox.y1 << 16));
     /* Video Window I Right and Bottom Boundaries */
-	WRITE_VPR(pSmi, 0x18, dstBox.x2 + (dstBox.y2 << 16));
+    WRITE_VPR(pSmi, 0x18, dstBox.x2 + (dstBox.y2 << 16));
     /* Video Window I Source Width and Offset */
-	WRITE_VPR(pSmi, 0x20, (vid_pitch / 8) + ((vid_pitch / 8) << 16));
+    WRITE_VPR(pSmi, 0x20, (vid_pitch / 8) + ((vid_pitch / 8) << 16));
     /* Video Window I Stretch Factor */
-	WRITE_VPR(pSmi, 0x24, (xscale << 8) + yscale);
+    WRITE_VPR(pSmi, 0x24, (xscale << 8) + yscale);
 
     if (pPort->Attribute[XV_INTERLACED]) {
 	/* Video Window II Left and Top Boundaries */
@@ -1360,8 +1306,7 @@ SMI_PutVideo(
 	WRITE_CPR(pSmi, 0x10, vid_address / 8 + vid_pitch / 8);
 	/* Capture Port Source Offset Address */
 	WRITE_CPR(pSmi, 0x14, 2*(vid_pitch / 8) + ((2*(vid_pitch / 8)) << 16));
-    }
-    else {
+    } else {
 	/* Video Source Clipping Control */
 	WRITE_CPR(pSmi, 0x04, left + (top << 16));
 	/* Video Source Capture Size Control */
@@ -1374,13 +1319,13 @@ SMI_PutVideo(
 	WRITE_CPR(pSmi, 0x14, (vid_pitch / 8) + ((vid_pitch / 8) << 16));
     }
 
-	WRITE_CPR(pSmi, 0x00, cpr00);
-	WRITE_VPR(pSmi, 0x00, vpr00);
+    WRITE_CPR(pSmi, 0x00, cpr00);
+    WRITE_VPR(pSmi, 0x00, vpr00);
 
     pPort->videoStatus = CLIENT_VIDEO_ON;
     DEBUG((VERBLEV, "SMI_PutVideo success\n"));
     LEAVE_PROC("SMI_PutVideo");
-	return(Success);
+    return Success;
 }
 #endif
 
@@ -1392,50 +1337,40 @@ SMI_StopVideo(
 	Bool		shutdown
 )
 {
-	SMI_PortPtr pPort = (SMI_PortPtr) data;
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMI_PortPtr pPort = (SMI_PortPtr) data;
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_StopVideo");
+    ENTER_PROC("SMI_StopVideo");
 
-	REGION_EMPTY(pScrn->pScreen, &pPort->clip);
+    REGION_EMPTY(pScrn->pScreen, &pPort->clip);
 
-	if (shutdown)
-	{
-		if (pPort->videoStatus & CLIENT_VIDEO_ON)
-		{
-			if (pSmi->Chipset == SMI_COUGAR3DR)
-			{
-				WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
-			}
-			else
-			{
-				WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x01000008);
-			}
+    if (shutdown) {
+	if (pPort->videoStatus & CLIENT_VIDEO_ON) {
+	    if (pSmi->Chipset == SMI_COUGAR3DR) {
+		WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
+	    } else {
+		WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x01000008);
+	    }
 #if SMI_USE_CAPTURE
-			if (pSmi->Chipset != SMI_COUGAR3DR)
-			{
-				WRITE_CPR(pSmi, 0x00, READ_CPR(pSmi, 0x00) & ~0x00000001);
-				WRITE_VPR(pSmi, 0x54, READ_VPR(pSmi, 0x54) & ~0x00F00000);
-			}
-			/* #864		OUT_SEQ(pSmi, 0x21, IN_SEQ(pSmi, 0x21) | 0x04); */
+	    if (pSmi->Chipset != SMI_COUGAR3DR) {
+		WRITE_CPR(pSmi, 0x00, READ_CPR(pSmi, 0x00) & ~0x00000001);
+		WRITE_VPR(pSmi, 0x54, READ_VPR(pSmi, 0x54) & ~0x00F00000);
+	    }
+/* #864		OUT_SEQ(pSmi, 0x21, IN_SEQ(pSmi, 0x21) | 0x04); */
 #endif
-		}
-        if (pPort->area != NULL)
-		{
+	}
+        if (pPort->area != NULL) {
             xf86FreeOffscreenArea(pPort->area);
             pPort->area = NULL;
-		}
+	}
         pPort->videoStatus = 0;
         /* pPort->i2cDevice = 0;aaa*/
-	}
-	else
-	{
-        if (pPort->videoStatus & CLIENT_VIDEO_ON)
-		{
+    } else {
+        if (pPort->videoStatus & CLIENT_VIDEO_ON) {
             pPort->videoStatus |= OFF_TIMER;
             pPort->offTime = currentTime.milliseconds + OFF_DELAY;
-		}
 	}
+    }
 
 	LEAVE_PROC("SMI_StopVideo");
 }
@@ -1451,63 +1386,51 @@ SMI_SetPortAttribute(
 {
     int res;
     SMI_PortPtr pPort = (SMI_PortPtr) data;
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_SetPortAttribute");
+    ENTER_PROC("SMI_SetPortAttribute");
 
     if (attribute == xvColorKey) {
-		int r, g, b;
+	int r, g, b;
 
         pPort->Attribute[XV_COLORKEY] = value;
-		switch (pScrn->depth)
-		{
-			case 8:
-				SetKeyReg(pSmi, FPR04, value & 0x00FF);
-				break;
-
-			case 15:
-			case 16:
-				SetKeyReg(pSmi, FPR04, value & 0xFFFF);
-				break;
-
-			default:
-				r = (value & pScrn->mask.red) >> pScrn->offset.red;
-				g = (value & pScrn->mask.green) >> pScrn->offset.green;
-				b = (value & pScrn->mask.blue) >> pScrn->offset.blue;
-				SetKeyReg(pSmi, FPR04,
-						((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3));
-				break;
-		}
-	res = Success;
+	switch (pScrn->depth) {
+	case 8:
+	    SetKeyReg(pSmi, FPR04, value & 0x00FF);
+	    break;
+	case 15:
+	case 16:
+	    SetKeyReg(pSmi, FPR04, value & 0xFFFF);
+	    break;
+	default:
+	    r = (value & pScrn->mask.red) >> pScrn->offset.red;
+	    g = (value & pScrn->mask.green) >> pScrn->offset.green;
+	    b = (value & pScrn->mask.blue) >> pScrn->offset.blue;
+	    SetKeyReg(pSmi, FPR04, ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3));
+	    break;
 	}
-    else if (attribute == xvInterlaced) {
+	res = Success;
+    } else if (attribute == xvInterlaced) {
         pPort->Attribute[XV_INTERLACED] = (value != 0);
 	res = Success;
-		}
-    else if (attribute == xvEncoding) {
+    } else if (attribute == xvEncoding) {
         res = SetAttr(pScrn, XV_ENCODING, value);
-	}
-    else if (attribute == xvBrightness) {
+    } else if (attribute == xvBrightness) {
         res = SetAttr(pScrn, XV_BRIGHTNESS, value);
-    }
-    else if (attribute == xvCapBrightness) {
+    } else if (attribute == xvCapBrightness) {
         res = SetAttr(pScrn, XV_CAPTURE_BRIGHTNESS, value);
-    }
-    else if (attribute == xvContrast) {
+    } else if (attribute == xvContrast) {
         res = SetAttr(pScrn, XV_CONTRAST, value);
-    }
-    else if (attribute == xvSaturation) {
+    } else if (attribute == xvSaturation) {
         res = SetAttr(pScrn, XV_SATURATION, value);
-    }
-    else if (attribute == xvHue) {
+    } else if (attribute == xvHue) {
         res = SetAttr(pScrn, XV_HUE, value);
-    }
-    else {
+    } else {
         res = BadMatch;
-	}
+    }
 
-	LEAVE_PROC("SMI_SetPortAttribute");
-    return(res);
+    LEAVE_PROC("SMI_SetPortAttribute");
+    return res;
 }
 
 
@@ -1521,7 +1444,7 @@ SMI_GetPortAttribute(
 {
     SMI_PortPtr pPort = (SMI_PortPtr) data;
 
-	ENTER_PROC("SMI_GetPortAttribute");
+    ENTER_PROC("SMI_GetPortAttribute");
     if (attribute == xvEncoding)
         *value = pPort->Attribute[XV_ENCODING];
     else if (attribute == xvBrightness)
@@ -1536,15 +1459,13 @@ SMI_GetPortAttribute(
         *value = pPort->Attribute[XV_HUE];
     else if (attribute == xvColorKey)
         *value = pPort->Attribute[XV_COLORKEY];
-
-	else
-	{
-		LEAVE_PROC("SMI_GetPortAttribute");
-		return(BadMatch);
-	}
-
+    else {
 	LEAVE_PROC("SMI_GetPortAttribute");
-	return(Success);
+	return BadMatch;
+    }
+
+    LEAVE_PROC("SMI_GetPortAttribute");
+    return Success;
 }
 
 
@@ -1561,14 +1482,14 @@ SMI_QueryBestSize(
 	pointer			data
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	ENTER_PROC("SMI_QueryBestSize");
+    ENTER_PROC("SMI_QueryBestSize");
 
-	*p_w = min(drw_w, pSmi->lcdWidth);
-	*p_h = min(drw_h, pSmi->lcdHeight);
+    *p_w = min(drw_w, pSmi->lcdWidth);
+    *p_h = min(drw_h, pSmi->lcdHeight);
 
-	LEAVE_PROC("SMI_QueryBestSize");
+    LEAVE_PROC("SMI_QueryBestSize");
 }
 
 
@@ -1593,113 +1514,102 @@ SMI_PutImage(
 	DrawablePtr		pDraw
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
     SMI_PortPtr pPort = (SMI_PortPtr) pSmi->ptrAdaptor->pPortPrivates[0].ptr;
-	INT32 x1, y1, x2, y2;
-	int bpp = 0;
-	int fbPitch, srcPitch, srcPitch2 = 0, dstPitch, areaHeight;
-	BoxRec dstBox;
-	CARD32 offset, offset2 = 0, offset3 = 0, tmp;
-	int left, top, nPixels, nLines;
-	unsigned char *dstStart;
-
-	ENTER_PROC("SMI_PutImage");
-
-	x1 = src_x;
-	y1 = src_y;
-	x2 = src_x + src_w;
-	y2 = src_y + src_h;
-
-	dstBox.x1 = drw_x;
-	dstBox.y1 = drw_y;
-	dstBox.x2 = drw_x + drw_w;
-	dstBox.y2 = drw_y + drw_h;
-
-	if (!SMI_ClipVideo(pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes, width,
-			height))
-	{
-		LEAVE_PROC("SMI_PutImage");
-		return(Success);
-	}
+    INT32 x1, y1, x2, y2;
+    int bpp = 0;
+    int fbPitch, srcPitch, srcPitch2 = 0, dstPitch, areaHeight;
+    BoxRec dstBox;
+    CARD32 offset, offset2 = 0, offset3 = 0, tmp;
+    int left, top, nPixels, nLines;
+    unsigned char *dstStart;
+
+    ENTER_PROC("SMI_PutImage");
+
+    x1 = src_x;
+    y1 = src_y;
+    x2 = src_x + src_w;
+    y2 = src_y + src_h;
+
+    dstBox.x1 = drw_x;
+    dstBox.y1 = drw_y;
+    dstBox.x2 = drw_x + drw_w;
+    dstBox.y2 = drw_y + drw_h;
+
+    if (!SMI_ClipVideo(pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes, width, height)) {
+	LEAVE_PROC("SMI_PutImage");
+	return Success;
+    }
 
-	dstBox.x1 -= pScrn->frameX0;
-	dstBox.y1 -= pScrn->frameY0;
-	dstBox.x2 -= pScrn->frameX0;
-	dstBox.y2 -= pScrn->frameY0;
+    dstBox.x1 -= pScrn->frameX0;
+    dstBox.y1 -= pScrn->frameY0;
+    dstBox.x2 -= pScrn->frameX0;
+    dstBox.y2 -= pScrn->frameY0;
 
-	if (pSmi->Bpp == 3)
-	{
-		fbPitch = pSmi->Stride;
-	}
-	else
-	{
-		fbPitch = pSmi->Stride * pSmi->Bpp;
-	}
+    if (pSmi->Bpp == 3) {
+	fbPitch = pSmi->Stride;
+    } else {
+	fbPitch = pSmi->Stride * pSmi->Bpp;
+    }
 
-	switch (id)
-	{
-		case FOURCC_YV12:
-			srcPitch  = (width + 3) & ~3;
-			offset2   = srcPitch * height;
-			srcPitch2 = ((width >> 1) + 3) & ~3;
-			offset3   = offset2 + (srcPitch2 * (height >> 1));
-			dstPitch  = ((width << 1) + 15) & ~15;
-			break;
-
-		case FOURCC_I420:
-			srcPitch  = (width + 3) & ~3;
-			offset3   = srcPitch * height;
-			srcPitch2 = ((width >> 1) + 3) & ~3;
-			offset2   = offset3 + (srcPitch2 * (height >> 1));
-			dstPitch  = ((width << 1) + 15) & ~15;
-			break;
-
-		case FOURCC_RV24:
-			bpp = 3;
-			srcPitch = width * bpp;
-			dstPitch = (srcPitch + 15) & ~15;
-			break;
-
-		case FOURCC_RV32:
-			bpp = 4;
-			srcPitch = width * bpp;
-			dstPitch = (srcPitch + 15) & ~15;
-			break;
-
-		case FOURCC_YUY2:
-		case FOURCC_RV15:
-		case FOURCC_RV16:
-		default:
-			bpp = 2;
-			srcPitch = width * bpp;
-			dstPitch = (srcPitch + 15) & ~15;
-			break;
-	}
+    switch (id) {
+    case FOURCC_YV12:
+	srcPitch  = (width + 3) & ~3;
+	offset2   = srcPitch * height;
+	srcPitch2 = ((width >> 1) + 3) & ~3;
+	offset3   = offset2 + (srcPitch2 * (height >> 1));
+	dstPitch  = ((width << 1) + 15) & ~15;
+	break;
+    case FOURCC_I420:
+	srcPitch  = (width + 3) & ~3;
+	offset3   = srcPitch * height;
+	srcPitch2 = ((width >> 1) + 3) & ~3;
+	offset2   = offset3 + (srcPitch2 * (height >> 1));
+	dstPitch  = ((width << 1) + 15) & ~15;
+	break;
+    case FOURCC_RV24:
+	bpp = 3;
+	srcPitch = width * bpp;
+	dstPitch = (srcPitch + 15) & ~15;
+	break;
+    case FOURCC_RV32:
+	bpp = 4;
+	srcPitch = width * bpp;
+	dstPitch = (srcPitch + 15) & ~15;
+	break;
+    case FOURCC_YUY2:
+    case FOURCC_RV15:
+    case FOURCC_RV16:
+    default:
+	bpp = 2;
+	srcPitch = width * bpp;
+	dstPitch = (srcPitch + 15) & ~15;
+	break;
+    }
 
-	areaHeight = ((dstPitch * height) + fbPitch - 1) / fbPitch;
+    areaHeight = ((dstPitch * height) + fbPitch - 1) / fbPitch;
     pPort->area = SMI_AllocateMemory(pScrn, pPort->area, areaHeight);
-    if (pPort->area == NULL)
-	{
-		LEAVE_PROC("SMI_PutImage");
-		return(BadAlloc);
-	}
+    if (pPort->area == NULL) {
+	LEAVE_PROC("SMI_PutImage");
+	return BadAlloc;
+    }
 
-	top = y1 >> 16;
-	left = (x1 >> 16) & ~1;
-	nPixels = ((((x2 + 0xFFFF) >> 16) + 1) & ~1) - left;
-	left *= bpp;
+    top = y1 >> 16;
+    left = (x1 >> 16) & ~1;
+    nPixels = ((((x2 + 0xFFFF) >> 16) + 1) & ~1) - left;
+    left *= bpp;
 
     offset = (pPort->area->box.y1 * fbPitch) + (top * dstPitch);
-	dstStart = pSmi->FBBase + offset + left;
+    dstStart = pSmi->FBBase + offset + left;
 
-   switch(id) {
+    switch(id) {
     case FOURCC_YV12:
     case FOURCC_I420:
 	top &= ~1;
 	tmp = ((top >> 1) * srcPitch2) + (left >> 2);
 	offset2 += tmp;
 	offset3 += tmp;
-	if(id == FOURCC_I420) {
+	if (id == FOURCC_I420) {
 	   tmp = offset2;
 	   offset2 = offset3;
 	   offset3 = tmp;
@@ -1723,125 +1633,111 @@ SMI_PutImage(
 #else
     if (!REGION_EQUAL(pScrn->pScreen, &pPort->clip, clipBoxes))
 #endif
-	{
+    {
         REGION_COPY(pScrn->pScreen, &pPort->clip, clipBoxes);
 	xf86XVFillKeyHelper(pScrn->pScreen, pPort->Attribute[XV_COLORKEY],
 			    clipBoxes);
-	}
+    }
 
-	if (pSmi->Chipset != SMI_COUGAR3DR)
-		SMI_DisplayVideo(pScrn, id, offset, width, height, dstPitch, x1, y1, x2, y2,
-				&dstBox, src_w, src_h, drw_w, drw_h);
-	else
-		SMI_DisplayVideo0730(pScrn, id, offset, width, height, dstPitch, x1, y1, x2, y2,
-				&dstBox, src_w, src_h, drw_w, drw_h);
+    if (pSmi->Chipset != SMI_COUGAR3DR)
+	SMI_DisplayVideo(pScrn, id, offset, width, height, dstPitch, x1, y1, x2, y2,
+			 &dstBox, src_w, src_h, drw_w, drw_h);
+    else
+	SMI_DisplayVideo0730(pScrn, id, offset, width, height, dstPitch, x1, y1, x2, y2,
+			     &dstBox, src_w, src_h, drw_w, drw_h);
 
     pPort->videoStatus = CLIENT_VIDEO_ON;
-	LEAVE_PROC("SMI_PutImage");
-	return(Success);
+    LEAVE_PROC("SMI_PutImage");
+    return Success;
 	
 }
 
 
 static int
 SMI_QueryImageAttributes(
-	ScrnInfoPtr		pScrn,
-	int				id,
+	ScrnInfoPtr	pScrn,
+	int		id,
 	unsigned short	*width,
 	unsigned short	*height,
-	int				*pitches,
-	int				*offsets
+	int		*pitches,
+	int		*offsets
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int size, tmp;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int size, tmp;
 
-	ENTER_PROC("SMI_QueryImageAttributes");
+    ENTER_PROC("SMI_QueryImageAttributes");
 
-	if (*width > pSmi->lcdWidth)
-	{
-		*width = pSmi->lcdWidth;
+    if (*width > pSmi->lcdWidth) {
+	*width = pSmi->lcdWidth;
+    }
+    if (*height > pSmi->lcdHeight) {
+	*height = pSmi->lcdHeight;
+    }
+
+    *width = (*width + 1) & ~1;
+    if (offsets != NULL) {
+	offsets[0] = 0;
+    }
+
+    switch (id) {
+    case FOURCC_YV12:
+    case FOURCC_I420:
+	*height = (*height + 1) & ~1;
+	size = (*width + 3) & ~3;
+	if (pitches != NULL) {
+	    pitches[0] = size;
 	}
-	if (*height > pSmi->lcdHeight)
-	{
-		*height = pSmi->lcdHeight;
+	size *= *height;
+	if (offsets != NULL) {
+	    offsets[1] = size;
 	}
-
-	*width = (*width + 1) & ~1;
-	if (offsets != NULL)
-	{
-		offsets[0] = 0;
+	tmp = ((*width >> 1) + 3) & ~3;
+	if (pitches != NULL) {
+	    pitches[1] = pitches[2] = tmp;
 	}
-
-	switch (id)
-	{
-		case FOURCC_YV12:
-		case FOURCC_I420:
-			*height = (*height + 1) & ~1;
-			size = (*width + 3) & ~3;
-			if (pitches != NULL)
-			{
-				pitches[0] = size;
-			}
-			size *= *height;
-			if (offsets != NULL)
-			{
-				offsets[1] = size;
-			}
-			tmp = ((*width >> 1) + 3) & ~3;
-			if (pitches != NULL)
-			{
-				pitches[1] = pitches[2] = tmp;
-			}
-			tmp *= (*height >> 1);
-			size += tmp;
-			if (offsets != NULL)
-			{
-				offsets[2] = size;
-			}
-			size += tmp;
-			break;
-
-		case FOURCC_YUY2:
-		case FOURCC_RV15:
-		case FOURCC_RV16:
-		default:
-			size = *width * 2;
-			if (pitches != NULL)
-			{
-				pitches[0] = size;
-			}
-			size *= *height;
-			break;
-
-		case FOURCC_RV24:
-			size = *width * 3;
-			if (pitches != NULL)
-			{
-				pitches[0] = size;
-			}
-			size *= *height;
-			break;
-
-		case FOURCC_RV32:
-			size = *width * 4;
-			if (pitches != NULL)
-			{
-				pitches[0] = size;
-			}
-			size *= *height;
-			break;
+	tmp *= (*height >> 1);
+	size += tmp;
+	if (offsets != NULL) {
+	    offsets[2] = size;
+	}
+	size += tmp;
+	break;
+    case FOURCC_YUY2:
+    case FOURCC_RV15:
+    case FOURCC_RV16:
+    default:
+	size = *width * 2;
+	if (pitches != NULL) {
+	    pitches[0] = size;
 	}
+	size *= *height;
+	break;
+    case FOURCC_RV24:
+	size = *width * 3;
+	if (pitches != NULL) {
+	    pitches[0] = size;
+	}
+	size *= *height;
+	break;
+    case FOURCC_RV32:
+	size = *width * 4;
+	if (pitches != NULL) {
+	    pitches[0] = size;
+	}
+	size *= *height;
+	break;
+    }
 
-	LEAVE_PROC("SMI_QueryImageAttributes");
-	return(size);
+    LEAVE_PROC("SMI_QueryImageAttributes");
+    return size;
 }
 
 
 /******************************************************************************\
-**																			  **
-**						S U P P O R T   F U N C T I O N S					  **
-**																			  **
+**									      **
+**	S U P P O R T   F U N C T I O N S				      **
+**									      **
 \******************************************************************************/
 #if 0
 static void
@@ -1874,67 +1770,61 @@ SMI_ClipVideo(
 {
     ScreenPtr pScreen = pScrn->pScreen;
     INT32 vscale, hscale;
-	BoxPtr extents = REGION_EXTENTS(pScreen, reg);
-	int diff;
+    BoxPtr extents = REGION_EXTENTS(pScreen, reg);
+    int diff;
 
-	ENTER_PROC("SMI_ClipVideo");
+    ENTER_PROC("SMI_ClipVideo");
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
-	/* PDR#941 */
-	extents->x1 = max(extents->x1, pScrn->frameX0);
-	extents->y1 = max(extents->y1, pScrn->frameY0);
+    /* PDR#941 */
+    extents->x1 = max(extents->x1, pScrn->frameX0);
+    extents->y1 = max(extents->y1, pScrn->frameY0);
 
-	hscale = ((*x2 - *x1) << 16) / (dst->x2 - dst->x1);
-	vscale = ((*y2 - *y1) << 16) / (dst->y2 - dst->y1);
+    hscale = ((*x2 - *x1) << 16) / (dst->x2 - dst->x1);
+    vscale = ((*y2 - *y1) << 16) / (dst->y2 - dst->y1);
 
-	*x1 <<= 16; *y1 <<= 16;
-	*x2 <<= 16; *y2 <<= 16;
+    *x1 <<= 16; *y1 <<= 16;
+    *x2 <<= 16; *y2 <<= 16;
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
 
-	diff = extents->x1 - dst->x1;
-	if (diff > 0)
-	{
-		dst->x1 = extents->x1;
-		*x1 += diff * hscale;
-	}
+    diff = extents->x1 - dst->x1;
+    if (diff > 0) {
+	dst->x1 = extents->x1;
+	*x1 += diff * hscale;
+    }
 
-	diff = extents->y1 - dst->y1;
-	if (diff > 0)
-	{
-		dst->y1 = extents->y1;
-		*y1 += diff * vscale;
-	}
+    diff = extents->y1 - dst->y1;
+    if (diff > 0) {
+	dst->y1 = extents->y1;
+	*y1 += diff * vscale;
+    }
 
-	diff = dst->x2 - extents->x2;
-	if (diff > 0)
-	{
-		dst->x2 = extents->x2; /* PDR#687 */
-		*x2 -= diff * hscale;
-	}
+    diff = dst->x2 - extents->x2;
+    if (diff > 0) {
+	dst->x2 = extents->x2; /* PDR#687 */
+	*x2 -= diff * hscale;
+    }
 
-	diff = dst->y2 - extents->y2;
-	if (diff > 0)
-	{
-		dst->y2 = extents->y2;
-		*y2 -= diff * vscale;
-	}
+    diff = dst->y2 - extents->y2;
+    if (diff > 0) {
+	dst->y2 = extents->y2;
+	*y2 -= diff * vscale;
+    }
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
 
-	if (*x1 < 0)
-	{
-		diff = (-*x1 + hscale - 1) / hscale;
-		dst->x1 += diff;
-		*x1 += diff * hscale;
-	}
+    if (*x1 < 0) {
+	diff = (-*x1 + hscale - 1) / hscale;
+	dst->x1 += diff;
+	*x1 += diff * hscale;
+    }
 
-	if (*y1 < 0)
-	{
-		diff = (-*y1 + vscale - 1) / vscale;
-		dst->y1 += diff;
-		*y1 += diff * vscale;
-	}
+    if (*y1 < 0) {
+	diff = (-*y1 + vscale - 1) / vscale;
+	dst->y1 += diff;
+	*y1 += diff * vscale;
+    }
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
 
@@ -1958,40 +1848,37 @@ SMI_ClipVideo(
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
 
-	if ((*x1 >= *x2) || (*y1 >= *y2))
-	{
-		LEAVE_PROC("SMI_ClipVideo");
-		return(FALSE);
-	}
+    if ((*x1 >= *x2) || (*y1 >= *y2)) {
+	LEAVE_PROC("SMI_ClipVideo");
+	return FALSE;
+    }
 
-	if (   (dst->x1 != extents->x1) || (dst->y1 != extents->y1)
-		|| (dst->x2 != extents->x2) || (dst->y2 != extents->y2)
-	)
-	{
-		RegionRec clipReg;
-		REGION_INIT(pScreen, &clipReg, dst, 1);
-		REGION_INTERSECT(pScreen, reg, reg, &clipReg);
-		REGION_UNINIT(pScreen, &clipReg);
-	}
+    if ((dst->x1 != extents->x1) || (dst->y1 != extents->y1) ||
+	(dst->x2 != extents->x2) || (dst->y2 != extents->y2)) {
+	RegionRec clipReg;
+	REGION_INIT(pScreen, &clipReg, dst, 1);
+	REGION_INTERSECT(pScreen, reg, reg, &clipReg);
+	REGION_UNINIT(pScreen, &clipReg);
+    }
 
     DEBUG((VERBLEV, "ClipVideo(%d): x1=%d y1=%d x2=%d y2=%d\n",  __LINE__, *x1 >> 16, *y1 >> 16, *x2 >> 16, *y2 >> 16));
 
-	LEAVE_PROC("SMI_ClipVideo");
-	return(TRUE);
+    LEAVE_PROC("SMI_ClipVideo");
+    return TRUE;
 }
 
 static void
 SMI_DisplayVideo(
 	ScrnInfoPtr	pScrn,
-	int			id,
-	int			offset,
+	int		id,
+	int		offset,
 	short		width,
 	short		height,
-	int			pitch,
-	int			x1,
-	int			y1,
-	int			x2,
-	int			y2,
+	int		pitch,
+	int		x1,
+	int		y1,
+	int		x2,
+	int		y2,
 	BoxPtr		dstBox,
 	short		vid_w,
 	short		vid_h,
@@ -1999,83 +1886,71 @@ SMI_DisplayVideo(
 	short		drw_h
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD32 vpr00;
-	int hstretch, vstretch;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD32 vpr00;
+    int hstretch, vstretch;
 
-	ENTER_PROC("SMI_DisplayVideo");
+    ENTER_PROC("SMI_DisplayVideo");
 
-	vpr00 = READ_VPR(pSmi, 0x00) & ~0x0CB800FF;
+    vpr00 = READ_VPR(pSmi, 0x00) & ~0x0CB800FF;
 
-	switch (id)
-	{
-		case FOURCC_YV12:
-		case FOURCC_I420:
-		case FOURCC_YUY2:
-			vpr00 |= 0x6;
-			break;
-
-		case FOURCC_RV15:
-			vpr00 |= 0x1;
-			break;
-
-		case FOURCC_RV16:
-			vpr00 |= 0x2;
-			break;
-
-		case FOURCC_RV24:
-			vpr00 |= 0x4;
-			break;
-
-		case FOURCC_RV32:
-			vpr00 |= 0x3;
-			break;
-	}
+    switch (id) {
+    case FOURCC_YV12:
+    case FOURCC_I420:
+    case FOURCC_YUY2:
+	vpr00 |= 0x6;
+	break;
+    case FOURCC_RV15:
+	vpr00 |= 0x1;
+	break;
+    case FOURCC_RV16:
+	vpr00 |= 0x2;
+	break;
+    case FOURCC_RV24:
+	vpr00 |= 0x4;
+	break;
+    case FOURCC_RV32:
+	vpr00 |= 0x3;
+	break;
+    }
 
-	
-	if (drw_w > vid_w)
-	{
-		hstretch = (2560 * vid_w / drw_w + 5) / 10;
-	}
-	else
-	{
-		hstretch = 0;
-	}
+    if (drw_w > vid_w) {
+	hstretch = (2560 * vid_w / drw_w + 5) / 10;
+    } else {
+	hstretch = 0;
+    }
 
-	if (drw_h > vid_h)
-	{
-		vstretch = (2560 * vid_h / drw_h + 5) / 10;
-		vpr00 |= 1 << 21;
-	}
-	else
-	{
-		vstretch = 0;
-	}
+    if (drw_h > vid_h) {
+	vstretch = (2560 * vid_h / drw_h + 5) / 10;
+	vpr00 |= 1 << 21;
+    } else {
+	vstretch = 0;
+    }
 #if 0
-	SMI_WaitForSync(pScrn);
+    SMI_WaitForSync(pScrn);
 #endif
-	WRITE_VPR(pSmi, 0x00, vpr00 | (1 << 3) | (1 << 20));
-	WRITE_VPR(pSmi, 0x14, (dstBox->x1) | (dstBox->y1 << 16));
-	WRITE_VPR(pSmi, 0x18, (dstBox->x2) | (dstBox->y2 << 16));
-	WRITE_VPR(pSmi, 0x1C, offset >> 3);
-	WRITE_VPR(pSmi, 0x20, (pitch >> 3) | ((pitch >> 3) << 16));
-	WRITE_VPR(pSmi, 0x24, (hstretch << 8) | vstretch);
-
-	LEAVE_PROC("SMI_DisplayVideo");
+    WRITE_VPR(pSmi, 0x00, vpr00 | (1 << 3) | (1 << 20));
+    WRITE_VPR(pSmi, 0x14, (dstBox->x1) | (dstBox->y1 << 16));
+    WRITE_VPR(pSmi, 0x18, (dstBox->x2) | (dstBox->y2 << 16));
+    WRITE_VPR(pSmi, 0x1C, offset >> 3);
+    WRITE_VPR(pSmi, 0x20, (pitch >> 3) | ((pitch >> 3) << 16));
+    WRITE_VPR(pSmi, 0x24, (hstretch << 8) | vstretch);
+
+    LEAVE_PROC("SMI_DisplayVideo");
 }
 
 static void
 SMI_DisplayVideo0730(
 	ScrnInfoPtr	pScrn,
-	int			id,
-	int			offset,
+	int		id,
+	int		offset,
 	short		width,
 	short		height,
-	int			pitch,
-	int			x1,
-	int			y1,
-	int			x2,
-	int			y2,
+	int		pitch,
+	int		x1,
+	int		y1,
+	int		x2,
+	int		y2,
 	BoxPtr		dstBox,
 	short		vid_w,
 	short		vid_h,
@@ -2083,117 +1958,96 @@ SMI_DisplayVideo0730(
 	short		drw_h
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	CARD32 fpr00;
-	int hstretch, vstretch;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    CARD32 fpr00;
+    int hstretch, vstretch;
 
-	ENTER_PROC("SMI_DisplayVideo0730");
+    ENTER_PROC("SMI_DisplayVideo0730");
 
-	fpr00 = READ_FPR(pSmi, 0x00) & ~(FPR00_MASKBITS);
+    fpr00 = READ_FPR(pSmi, 0x00) & ~(FPR00_MASKBITS);
 
-	switch (id)
-	{
-		case FOURCC_YV12:
-		case FOURCC_I420:
-		case FOURCC_YUY2:
-			fpr00 |= FPR00_FMT_YUV422;
-			break;
-
-		case FOURCC_RV15:
-			fpr00 |= FPR00_FMT_15P;
-			break;
-
-		case FOURCC_RV16:
-			fpr00 |= FPR00_FMT_16P;
-			break;
-
-		case FOURCC_RV24:
-			fpr00 |= FPR00_FMT_24P;
-			break;
-
-		case FOURCC_RV32:
-			fpr00 |= FPR00_FMT_32P;
-			break;
-	}
+    switch (id) {
+    case FOURCC_YV12:
+    case FOURCC_I420:
+    case FOURCC_YUY2:
+	fpr00 |= FPR00_FMT_YUV422;
+	break;
+    case FOURCC_RV15:
+	fpr00 |= FPR00_FMT_15P;
+	break;
+    case FOURCC_RV16:
+	fpr00 |= FPR00_FMT_16P;
+	break;
+    case FOURCC_RV24:
+	fpr00 |= FPR00_FMT_24P;
+	break;
+    case FOURCC_RV32:
+	fpr00 |= FPR00_FMT_32P;
+	break;
+    }
 
-	/* the formulas for calculating the stretch values do not match the
-	   documentation, but they're the same as the ddraw driver and they work */
-	if (drw_w > vid_w)
-	{
-		hstretch = (8192 * vid_w / drw_w);
-	}
-	else
-	{
-		hstretch = 0;
-	}
+    /* the formulas for calculating the stretch values do not match the
+       documentation, but they're the same as the ddraw driver and they work */
+    if (drw_w > vid_w) {
+	hstretch = (8192 * vid_w / drw_w);
+    } else {
+	hstretch = 0;
+    }
 
-	if (drw_h > vid_h)
-	{
-		vstretch = (8192 * vid_h / drw_h);
-	}
-	else
-	{
-		vstretch = 0;
-	}
-	
+    if (drw_h > vid_h) {
+	vstretch = (8192 * vid_h / drw_h);
+    } else {
+	vstretch = 0;
+    }
 
-	WRITE_FPR(pSmi, FPR00, fpr00 | FPR00_VWIENABLE | FPR00_VWIKEYENABLE);
-	WRITE_FPR(pSmi, FPR14, (dstBox->x1) | (dstBox->y1 << 16));
-	WRITE_FPR(pSmi, FPR18, (dstBox->x2) | (dstBox->y2 << 16));
-	WRITE_FPR(pSmi, FPR1C, offset >> 3);
-	WRITE_FPR(pSmi, FPR20, (pitch >> 3) | ((pitch >> 3) << 16));
- 	WRITE_FPR(pSmi, FPR24, (hstretch & 0xFF00) | ((vstretch & 0xFF00)>>8)); 
- 	WRITE_FPR(pSmi, FPR68, ((hstretch & 0x00FF)<<8) | (vstretch & 0x00FF)); 
+    WRITE_FPR(pSmi, FPR00, fpr00 | FPR00_VWIENABLE | FPR00_VWIKEYENABLE);
+    WRITE_FPR(pSmi, FPR14, (dstBox->x1) | (dstBox->y1 << 16));
+    WRITE_FPR(pSmi, FPR18, (dstBox->x2) | (dstBox->y2 << 16));
+    WRITE_FPR(pSmi, FPR1C, offset >> 3);
+    WRITE_FPR(pSmi, FPR20, (pitch >> 3) | ((pitch >> 3) << 16));
+    WRITE_FPR(pSmi, FPR24, (hstretch & 0xFF00) | ((vstretch & 0xFF00)>>8)); 
+    WRITE_FPR(pSmi, FPR68, ((hstretch & 0x00FF)<<8) | (vstretch & 0x00FF)); 
 
-	LEAVE_PROC("SMI_DisplayVideo0730");
+    LEAVE_PROC("SMI_DisplayVideo0730");
 }
 
 static void
 SMI_BlockHandler(
-	int		i,
+	int	i,
 	pointer	blockData,
 	pointer	pTimeout,
 	pointer	pReadMask
 )
 {
-	ScreenPtr	pScreen = screenInfo.screens[i];
-	ScrnInfoPtr	pScrn	= xf86Screens[i];
-	SMIPtr		pSmi    = SMIPTR(pScrn);
+    ScreenPtr	pScreen = screenInfo.screens[i];
+    ScrnInfoPtr	pScrn	= xf86Screens[i];
+    SMIPtr	pSmi    = SMIPTR(pScrn);
     SMI_PortPtr pPort = (SMI_PortPtr) pSmi->ptrAdaptor->pPortPrivates[0].ptr;
 
-	pScreen->BlockHandler = pSmi->BlockHandler;
-	(*pScreen->BlockHandler)(i, blockData, pTimeout, pReadMask);
-	pScreen->BlockHandler = SMI_BlockHandler;
+    pScreen->BlockHandler = pSmi->BlockHandler;
+    (*pScreen->BlockHandler)(i, blockData, pTimeout, pReadMask);
+    pScreen->BlockHandler = SMI_BlockHandler;
 
-    if (pPort->videoStatus & TIMER_MASK)
-	{
-		UpdateCurrentTime();
-        if (pPort->videoStatus & OFF_TIMER)
-		{
-            if (pPort->offTime < currentTime.milliseconds)
-			{
-				if (pSmi->Chipset == SMI_COUGAR3DR)
-				{
-					WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
-				}
-				else
-				{
-					WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x00000008);
-				}
+    if (pPort->videoStatus & TIMER_MASK) {
+	UpdateCurrentTime();
+        if (pPort->videoStatus & OFF_TIMER) {
+            if (pPort->offTime < currentTime.milliseconds) {
+		if (pSmi->Chipset == SMI_COUGAR3DR) {
+		    WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
+		} else {
+		    WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x00000008);
+		}
                 pPort->videoStatus = FREE_TIMER;
                 pPort->freeTime = currentTime.milliseconds + FREE_DELAY;
-			}
-		}
-		else
-		{
-            if (pPort->freeTime < currentTime.milliseconds)
-			{
+	    }
+	} else {
+            if (pPort->freeTime < currentTime.milliseconds) {
                 xf86FreeOffscreenArea(pPort->area);
                 pPort->area = NULL;
-			}
+	    }
             pPort->videoStatus = 0;
-		}
 	}
+    }
 }
 
 #if 0
@@ -2251,9 +2105,9 @@ SMI_SendI2C(
 #endif
 
 /******************************************************************************\
-**																			  **
-**				 O F F S C R E E N   M E M O R Y   M A N A G E R			  **
-**																			  **
+**									      **
+**	 O F F S C R E E N   M E M O R Y   M A N A G E R		      **
+**									      **
 \******************************************************************************/
 
 static void
@@ -2261,204 +2115,185 @@ SMI_InitOffscreenImages(
 	ScreenPtr	pScreen
 )
 {
-	XF86OffscreenImagePtr offscreenImages;
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	SMIPtr pSmi = SMIPTR(pScrn);
-	SMI_PortPtr pPort = (SMI_PortPtr) pSmi->ptrAdaptor->pPortPrivates[0].ptr;
+    XF86OffscreenImagePtr offscreenImages;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SMIPtr pSmi = SMIPTR(pScrn);
+    SMI_PortPtr pPort = (SMI_PortPtr) pSmi->ptrAdaptor->pPortPrivates[0].ptr;
 
-	ENTER_PROC("SMI_InitOffscreenImages");
+    ENTER_PROC("SMI_InitOffscreenImages");
 
-	offscreenImages = xalloc(sizeof(XF86OffscreenImageRec));
-	if (offscreenImages == NULL)
-	{
-		LEAVE_PROC("SMI_InitOffscreenImages");
-		return;
-	}
+    offscreenImages = xalloc(sizeof(XF86OffscreenImageRec));
+    if (offscreenImages == NULL) {
+	LEAVE_PROC("SMI_InitOffscreenImages");
+	return;
+    }
 
-	offscreenImages->image = SMI_VideoImages;
-	offscreenImages->flags = VIDEO_OVERLAID_IMAGES
-						   | VIDEO_CLIP_TO_VIEWPORT;
-	offscreenImages->alloc_surface = SMI_AllocSurface;
-	offscreenImages->free_surface = SMI_FreeSurface;
-	offscreenImages->display = SMI_DisplaySurface;
-	offscreenImages->stop = SMI_StopSurface;
-	offscreenImages->getAttribute = SMI_GetSurfaceAttribute;
-	offscreenImages->setAttribute = SMI_SetSurfaceAttribute;
-	offscreenImages->max_width = pSmi->lcdWidth;
-	offscreenImages->max_height = pSmi->lcdHeight;
-	if (!pPort->I2CDev.SlaveAddr) {
-	    offscreenImages->num_attributes = nElems(SMI_VideoAttributes);
-	    offscreenImages->attributes = SMI_VideoAttributes; 
-	} else {
-	    offscreenImages->num_attributes = 
-		nElems(SMI_VideoAttributesSAA711x);
-	    offscreenImages->attributes = SMI_VideoAttributesSAA711x; 
-	}
-	xf86XVRegisterOffscreenImages(pScreen, offscreenImages, 1);
+    offscreenImages->image = SMI_VideoImages;
+    offscreenImages->flags = VIDEO_OVERLAID_IMAGES
+			   | VIDEO_CLIP_TO_VIEWPORT;
+    offscreenImages->alloc_surface = SMI_AllocSurface;
+    offscreenImages->free_surface = SMI_FreeSurface;
+    offscreenImages->display = SMI_DisplaySurface;
+    offscreenImages->stop = SMI_StopSurface;
+    offscreenImages->getAttribute = SMI_GetSurfaceAttribute;
+    offscreenImages->setAttribute = SMI_SetSurfaceAttribute;
+    offscreenImages->max_width = pSmi->lcdWidth;
+    offscreenImages->max_height = pSmi->lcdHeight;
+    if (!pPort->I2CDev.SlaveAddr) {
+	offscreenImages->num_attributes = nElems(SMI_VideoAttributes);
+	offscreenImages->attributes = SMI_VideoAttributes; 
+    } else {
+	offscreenImages->num_attributes = nElems(SMI_VideoAttributesSAA711x);
+	offscreenImages->attributes = SMI_VideoAttributesSAA711x; 
+    }
+    xf86XVRegisterOffscreenImages(pScreen, offscreenImages, 1);
 
-	LEAVE_PROC("SMI_InitOffscreenImages");
+    LEAVE_PROC("SMI_InitOffscreenImages");
 }
 
 static FBAreaPtr
 SMI_AllocateMemory(
 	ScrnInfoPtr	pScrn,
 	FBAreaPtr	area,
-	int			numLines
+	int		numLines
 )
 {
-	ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
+    ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
 
-	ENTER_PROC("SMI_AllocateMemory");
+    ENTER_PROC("SMI_AllocateMemory");
 
-	if (area != NULL)
-	{
-		if ((area->box.y2 - area->box.y1) >= numLines)
-		{
+    if (area != NULL) {
+	if ((area->box.y2 - area->box.y1) >= numLines) {
             LEAVE_PROC("SMI_AllocateMemory (area->box.y2 - area->box.y1) >= numLines ok");
-			return(area);
-		}
+	    return area;
+	}
 
-		if (xf86ResizeOffscreenArea(area, pScrn->displayWidth, numLines))
-		{
+	if (xf86ResizeOffscreenArea(area, pScrn->displayWidth, numLines)) {
             LEAVE_PROC("SMI_AllocateMemory xf86ResizeOffscreenArea ok");
-			return(area);
-		}
-
-		xf86FreeOffscreenArea(area);
+	    return area;
 	}
 
-	area = xf86AllocateOffscreenArea(pScreen, pScrn->displayWidth, numLines, 0,
-			NULL, NULL, NULL);
+	xf86FreeOffscreenArea(area);
+    }
+
+    area = xf86AllocateOffscreenArea(pScreen, pScrn->displayWidth, numLines, 0,
+				     NULL, NULL, NULL);
 
-	if (area == NULL)
-	{
-		int maxW, maxH;
+    if (area == NULL) {
+	int maxW, maxH;
 
-		xf86QueryLargestOffscreenArea(pScreen, &maxW, &maxH, 0,
+	xf86QueryLargestOffscreenArea(pScreen, &maxW, &maxH, 0,
 				FAVOR_WIDTH_THEN_AREA, PRIORITY_EXTREME);
 
 	DEBUG((VERBLEV, "QueryLargestOffscreenArea maxW=%d maxH=%d displayWidth=%d numlines=%d\n",
 	       maxW, maxH, pScrn->displayWidth, numLines));
-		if ((maxW < pScrn->displayWidth) || (maxH < numLines))
-		{
+	if ((maxW < pScrn->displayWidth) || (maxH < numLines)) {
             LEAVE_PROC("SMI_AllocateMemory (maxW < pScrn->displayWidth) || (maxH < numLines)");
-			return(NULL);
-		}
+	    return NULL;
+	}
 
-		xf86PurgeUnlockedOffscreenAreas(pScreen);
-		area = xf86AllocateOffscreenArea(pScreen, pScrn->displayWidth, numLines,
+	xf86PurgeUnlockedOffscreenAreas(pScreen);
+	area = xf86AllocateOffscreenArea(pScreen, pScrn->displayWidth, numLines,
 				0, NULL, NULL, NULL);
-	}
+    }
 
     DEBUG((VERBLEV, "area = %p\n", area));
-	LEAVE_PROC("SMI_AllocateMemory");
-	return(area);
+    LEAVE_PROC("SMI_AllocateMemory");
+    return area;
 }
 
 static int
 SMI_AllocSurface(
-	ScrnInfoPtr		pScrn,
-	int				id,
+	ScrnInfoPtr	pScrn,
+	int		id,
 	unsigned short	width,
 	unsigned short	height,
 	XF86SurfacePtr	surface
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
-	int numLines, pitch, fbPitch, bpp;
-	SMI_OffscreenPtr ptrOffscreen;
-	FBAreaPtr area;
+    SMIPtr pSmi = SMIPTR(pScrn);
+    int numLines, pitch, fbPitch, bpp;
+    SMI_OffscreenPtr ptrOffscreen;
+    FBAreaPtr area;
 
-	ENTER_PROC("SMI_AllocSurface");
+    ENTER_PROC("SMI_AllocSurface");
 
-	if ((width > pSmi->lcdWidth) || (height > pSmi->lcdHeight))
-	{
-		LEAVE_PROC("SMI_AllocSurface");
-		return(BadAlloc);
-	}
+    if ((width > pSmi->lcdWidth) || (height > pSmi->lcdHeight)) {
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
 
-	if (pSmi->Bpp == 3)
-	{
-		fbPitch = pSmi->Stride;
-	}
-	else
-	{
-		fbPitch = pSmi->Stride * pSmi->Bpp;
-	}
+    if (pSmi->Bpp == 3) {
+	fbPitch = pSmi->Stride;
+    } else {
+	fbPitch = pSmi->Stride * pSmi->Bpp;
+    }
 
-	width = (width + 1) & ~1;
-	switch (id)
-	{
-		case FOURCC_YV12:
-		case FOURCC_I420:
-		case FOURCC_YUY2:
-		case FOURCC_RV15:
-		case FOURCC_RV16:
-			bpp = 2;
-			break;
-
-		case FOURCC_RV24:
-			bpp = 3;
-			break;
-
-		case FOURCC_RV32:
-			bpp = 4;
-			break;
-
-		default:
-			LEAVE_PROC("SMI_AllocSurface");
-			return(BadAlloc);
-	}
-	pitch = (width * bpp + 15) & ~15;
+    width = (width + 1) & ~1;
+    switch (id) {
+    case FOURCC_YV12:
+    case FOURCC_I420:
+    case FOURCC_YUY2:
+    case FOURCC_RV15:
+    case FOURCC_RV16:
+	bpp = 2;
+	break;
+    case FOURCC_RV24:
+	bpp = 3;
+	break;
+    case FOURCC_RV32:
+	bpp = 4;
+	break;
+    default:
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
+    pitch = (width * bpp + 15) & ~15;
 
-	numLines = ((height * pitch) + fbPitch - 1) / fbPitch;
+    numLines = ((height * pitch) + fbPitch - 1) / fbPitch;
 
-	area = SMI_AllocateMemory(pScrn, NULL, numLines);
-	if (area == NULL)
-	{
-		LEAVE_PROC("SMI_AllocSurface");
-		return(BadAlloc);
-	}
+    area = SMI_AllocateMemory(pScrn, NULL, numLines);
+    if (area == NULL) {
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
 
-	surface->pitches = xalloc(sizeof(int));
-	if (surface->pitches == NULL)
-	{
-		xf86FreeOffscreenArea(area);
-		LEAVE_PROC("SMI_AllocSurface");
-		return(BadAlloc);
-	}
-	surface->offsets = xalloc(sizeof(int));
-	if (surface->offsets == NULL)
-	{
-		xfree(surface->pitches);
-		xf86FreeOffscreenArea(area);
-		LEAVE_PROC("SMI_AllocSurface");
-		return(BadAlloc);
-	}
+    surface->pitches = xalloc(sizeof(int));
+    if (surface->pitches == NULL) {
+	xf86FreeOffscreenArea(area);
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
+    surface->offsets = xalloc(sizeof(int));
+    if (surface->offsets == NULL) {
+	xfree(surface->pitches);
+	xf86FreeOffscreenArea(area);
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
 
-	ptrOffscreen = xalloc(sizeof(SMI_OffscreenRec));
-	if (ptrOffscreen == NULL)
-	{
-		xfree(surface->offsets);
-		xfree(surface->pitches);
-		xf86FreeOffscreenArea(area);
-		LEAVE_PROC("SMI_AllocSurface");
-		return(BadAlloc);
-	}
+    ptrOffscreen = xalloc(sizeof(SMI_OffscreenRec));
+    if (ptrOffscreen == NULL) {
+	xfree(surface->offsets);
+	xfree(surface->pitches);
+	xf86FreeOffscreenArea(area);
+	LEAVE_PROC("SMI_AllocSurface");
+	return BadAlloc;
+    }
 
-	surface->pScrn = pScrn;
-	surface->id = id;
-	surface->width = width;
-	surface->height = height;
-	surface->pitches[0] = pitch;
-	surface->offsets[0] = area->box.y1 * fbPitch;
-	surface->devPrivate.ptr = (pointer) ptrOffscreen;
+    surface->pScrn = pScrn;
+    surface->id = id;
+    surface->width = width;
+    surface->height = height;
+    surface->pitches[0] = pitch;
+    surface->offsets[0] = area->box.y1 * fbPitch;
+    surface->devPrivate.ptr = (pointer) ptrOffscreen;
 
-	ptrOffscreen->area = area;
-	ptrOffscreen->isOn = FALSE;
+    ptrOffscreen->area = area;
+    ptrOffscreen->isOn = FALSE;
 
-	LEAVE_PROC("SMI_AllocSurface");
-	return(Success);
+    LEAVE_PROC("SMI_AllocSurface");
+    return Success;
 }
 
 static int
@@ -2466,97 +2301,91 @@ SMI_FreeSurface(
 	XF86SurfacePtr	surface
 )
 {
-	SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
+    SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
 
-	ENTER_PROC("SMI_FreeSurface");
+    ENTER_PROC("SMI_FreeSurface");
 
-	if (ptrOffscreen->isOn)
-	{
-		SMI_StopSurface(surface);
-	}
+    if (ptrOffscreen->isOn) {
+	SMI_StopSurface(surface);
+    }
 
-	xf86FreeOffscreenArea(ptrOffscreen->area);
-	xfree(surface->pitches);
-	xfree(surface->offsets);
-	xfree(surface->devPrivate.ptr);
+    xf86FreeOffscreenArea(ptrOffscreen->area);
+    xfree(surface->pitches);
+    xfree(surface->offsets);
+    xfree(surface->devPrivate.ptr);
 
-	LEAVE_PROC("SMI_FreeSurface");
-	return(Success);
+    LEAVE_PROC("SMI_FreeSurface");
+    return Success;
 }
 
 static int
 SMI_DisplaySurface(
 	XF86SurfacePtr	surface,
-	short			vid_x,
-	short			vid_y,
-	short			drw_x,
-	short			drw_y,
-	short			vid_w,
-	short			vid_h,
-	short			drw_w,
-	short			drw_h,
-	RegionPtr		clipBoxes
+	short		vid_x,
+	short		vid_y,
+	short		drw_x,
+	short		drw_y,
+	short		vid_w,
+	short		vid_h,
+	short		drw_w,
+	short		drw_h,
+	RegionPtr	clipBoxes
 )
 {
-	SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
-	SMIPtr pSmi = SMIPTR(surface->pScrn);
+    SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
+    SMIPtr pSmi = SMIPTR(surface->pScrn);
     SMI_PortPtr pPort = pSmi->ptrAdaptor->pPortPrivates[0].ptr;
-	INT32 x1, y1, x2, y2;
-	BoxRec dstBox;
+    INT32 x1, y1, x2, y2;
+    BoxRec dstBox;
 
-	ENTER_PROC("SMI_DisplaySurface");
+    ENTER_PROC("SMI_DisplaySurface");
 
-	x1 = vid_x;
-	x2 = vid_x + vid_w;
-	y1 = vid_y;
-	y2 = vid_y + vid_h;
+    x1 = vid_x;
+    x2 = vid_x + vid_w;
+    y1 = vid_y;
+    y2 = vid_y + vid_h;
 
-	dstBox.x1 = drw_x;
-	dstBox.x2 = drw_x + drw_w;
-	dstBox.y1 = drw_y;
-	dstBox.y2 = drw_y + drw_h;
+    dstBox.x1 = drw_x;
+    dstBox.x2 = drw_x + drw_w;
+    dstBox.y1 = drw_y;
+    dstBox.y2 = drw_y + drw_h;
 
-	if (!SMI_ClipVideo(surface->pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes,
-			surface->width, surface->height))
-	{
-		LEAVE_PROC("SMI_DisplaySurface");
-		return(Success);
-	}
-
-	dstBox.x1 -= surface->pScrn->frameX0;
-	dstBox.y1 -= surface->pScrn->frameY0;
-	dstBox.x2 -= surface->pScrn->frameX0;
-	dstBox.y2 -= surface->pScrn->frameY0;
-
-	xf86XVFillKeyHelper(surface->pScrn->pScreen,
-			    pPort->Attribute[XV_COLORKEY], clipBoxes);
+    if (!SMI_ClipVideo(surface->pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes,
+			surface->width, surface->height)) {
+	LEAVE_PROC("SMI_DisplaySurface");
+	return Success;
+    }
 
-	if (pSmi->Chipset != SMI_COUGAR3DR)
-	{
-		SMI_ResetVideo(surface->pScrn);
-		SMI_DisplayVideo(surface->pScrn, surface->id, surface->offsets[0],
-				surface->width, surface->height, surface->pitches[0], x1, y1, x2,
-				y2, &dstBox, vid_w, vid_h, drw_w, drw_h);
-	}
-	else
-	{
-		SMI_ResetVideo(surface->pScrn);
-		SMI_DisplayVideo0730(surface->pScrn, surface->id, surface->offsets[0],
-				surface->width, surface->height, surface->pitches[0], x1, y1, x2,
-				y2, &dstBox, vid_w, vid_h, drw_w, drw_h);
-	}
+    dstBox.x1 -= surface->pScrn->frameX0;
+    dstBox.y1 -= surface->pScrn->frameY0;
+    dstBox.x2 -= surface->pScrn->frameX0;
+    dstBox.y2 -= surface->pScrn->frameY0;
+
+    xf86XVFillKeyHelper(surface->pScrn->pScreen,
+			pPort->Attribute[XV_COLORKEY], clipBoxes);
+
+    if (pSmi->Chipset != SMI_COUGAR3DR) {
+	SMI_ResetVideo(surface->pScrn);
+	SMI_DisplayVideo(surface->pScrn, surface->id, surface->offsets[0],
+			 surface->width, surface->height, surface->pitches[0], x1, y1, x2,
+			 y2, &dstBox, vid_w, vid_h, drw_w, drw_h);
+    } else {
+	SMI_ResetVideo(surface->pScrn);
+	SMI_DisplayVideo0730(surface->pScrn, surface->id, surface->offsets[0],
+			     surface->width, surface->height, surface->pitches[0], x1, y1, x2,
+			     y2, &dstBox, vid_w, vid_h, drw_w, drw_h);
+    }
 
-	ptrOffscreen->isOn = TRUE;
-    if (pPort->videoStatus & CLIENT_VIDEO_ON)
-	{
+    ptrOffscreen->isOn = TRUE;
+    if (pPort->videoStatus & CLIENT_VIDEO_ON) {
         REGION_EMPTY(surface->pScrn->pScreen, &pPort->clip);
-		UpdateCurrentTime();
+	UpdateCurrentTime();
         pPort->videoStatus = FREE_TIMER;
         pPort->freeTime = currentTime.milliseconds + FREE_DELAY;
-	}
+    }
 
-	LEAVE_PROC("SMI_DisplaySurface");
-	return(Success);
+    LEAVE_PROC("SMI_DisplaySurface");
+    return Success;
 }
 
 static int
@@ -2564,27 +2393,23 @@ SMI_StopSurface(
 	XF86SurfacePtr	surface
 )
 {
-	SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
+    SMI_OffscreenPtr ptrOffscreen = (SMI_OffscreenPtr) surface->devPrivate.ptr;
 
-	ENTER_PROC("SMI_StopSurface");
+    ENTER_PROC("SMI_StopSurface");
 
-	if (ptrOffscreen->isOn)
-	{
-		SMIPtr pSmi = SMIPTR(surface->pScrn);
-		if (pSmi->Chipset == SMI_COUGAR3DR)
-		{
-			WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
-		}
-		else
-		{
-			WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x00000008);
-		}
-
-		ptrOffscreen->isOn = FALSE;
+    if (ptrOffscreen->isOn) {
+	SMIPtr pSmi = SMIPTR(surface->pScrn);
+	if (pSmi->Chipset == SMI_COUGAR3DR) {
+	    WRITE_FPR(pSmi, FPR00, READ_FPR(pSmi, 0x00) & ~(FPR00_VWIENABLE));
+	} else {
+	    WRITE_VPR(pSmi, 0x00, READ_VPR(pSmi, 0x00) & ~0x00000008);
 	}
 
-	LEAVE_PROC("SMI_StopSurface");
-	return(Success);
+	ptrOffscreen->isOn = FALSE;
+    }
+
+    LEAVE_PROC("SMI_StopSurface");
+    return Success;
 }
 
 static int
@@ -2594,10 +2419,10 @@ SMI_GetSurfaceAttribute(
 	INT32		*value
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	return(SMI_GetPortAttribute(pScrn, attr, value,
-			(pointer) pSmi->ptrAdaptor->pPortPrivates[0].ptr));
+    return SMI_GetPortAttribute(pScrn, attr, value,
+			(pointer) pSmi->ptrAdaptor->pPortPrivates[0].ptr);
 }
 
 static int
@@ -2607,23 +2432,20 @@ SMI_SetSurfaceAttribute(
 	INT32		value
 )
 {
-	SMIPtr pSmi = SMIPTR(pScrn);
+    SMIPtr pSmi = SMIPTR(pScrn);
 
-	return(SMI_SetPortAttribute(pScrn, attr, value,
-			(pointer) pSmi->ptrAdaptor->pPortPrivates[0].ptr));
+    return SMI_SetPortAttribute(pScrn, attr, value,
+			(pointer) pSmi->ptrAdaptor->pPortPrivates[0].ptr);
 }
 
 static void
 SetKeyReg(SMIPtr pSmi, int reg, int value)
 {
-	if (pSmi->Chipset == SMI_COUGAR3DR)
-	{
-		WRITE_FPR(pSmi, reg, value);
-	}
-	else
-	{
-		WRITE_VPR(pSmi, reg, value);
-	}
+    if (pSmi->Chipset == SMI_COUGAR3DR) {
+	WRITE_FPR(pSmi, reg, value);
+    } else {
+	WRITE_VPR(pSmi, reg, value);
+    }
 }
 
 #else /* SMI_USE_VIDEO */
diff --git a/src/smi_video.h b/src/smi_video.h
index b63e4bc..ff15dc7 100644
--- a/src/smi_video.h
+++ b/src/smi_video.h
@@ -88,15 +88,15 @@ typedef struct
 
 typedef struct
 {
-	FBAreaPtr	area;
-	Bool		isOn;
+    FBAreaPtr	area;
+    Bool	isOn;
 
 } SMI_OffscreenRec, *SMI_OffscreenPtr;
 
 typedef struct
 {
-	CARD8		address;
-	CARD8		data;
+    CARD8	address;
+    CARD8	data;
 
 } SMI_I2CDataRec, *SMI_I2CDataPtr;