Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

1 files changed, 1180 insertions, 1159 deletions

diff --git a/hw/xfree86/common/xf86Mode.c b/hw/xfree86/common/xf86Mode.c
index d202d4079..ab4d595c7 100644
--- a/hw/xfree86/common/xf86Mode.c
+++ b/hw/xfree86/common/xf86Mode.c
@@ -99,16 +99,16 @@ printModeRejectMessage(int index, DisplayModePtr p, int status)
     const char *type;
 
     if (p->type & M_T_BUILTIN)
-	type = "built-in ";
+        type = "built-in ";
     else if (p->type & M_T_DEFAULT)
-	type = "default ";
+        type = "default ";
     else if (p->type & M_T_DRIVER)
-	type = "driver ";
+        type = "driver ";
     else
-	type = "";
+        type = "";
 
     xf86DrvMsg(index, X_INFO, "Not using %smode \"%s\" (%s)\n", type, p->name,
-	       xf86ModeStatusToString(status));
+               xf86ModeStatusToString(status));
 }
 
 /*
@@ -118,33 +118,32 @@ printModeRejectMessage(int index, DisplayModePtr p, int status)
  */
 int
 xf86GetNearestClock(ScrnInfoPtr scrp, int freq, Bool allowDiv2,
-    int DivFactor, int MulFactor, int *divider)
+                    int DivFactor, int MulFactor, int *divider)
 {
     int nearestClock = 0, nearestDiv = 1;
     int minimumGap = abs(freq - scrp->clock[0]);
     int i, j, k, gap;
 
     if (allowDiv2)
-	k = 2;
+        k = 2;
     else
-	k = 1;
+        k = 1;
 
     /* Must set this here in case the best match is scrp->clock[0] */
     if (divider != NULL)
-	*divider = 0;
-    
-    for (i = 0;  i < scrp->numClocks;  i++) {
-	for (j = 1; j <= k; j++) {
-	    gap = abs((freq * j) - ((scrp->clock[i] * DivFactor) / MulFactor));
-	    if ((gap < minimumGap) ||
-		((gap == minimumGap) && (j < nearestDiv))) {
-		minimumGap = gap;
-		nearestClock = i;
-		nearestDiv = j;
-		if (divider != NULL)
-		    *divider = (j - 1) * V_CLKDIV2;
-	    }
-	}
+        *divider = 0;
+
+    for (i = 0; i < scrp->numClocks; i++) {
+        for (j = 1; j <= k; j++) {
+            gap = abs((freq * j) - ((scrp->clock[i] * DivFactor) / MulFactor));
+            if ((gap < minimumGap) || ((gap == minimumGap) && (j < nearestDiv))) {
+                minimumGap = gap;
+                nearestClock = i;
+                nearestDiv = j;
+                if (divider != NULL)
+                    *divider = (j - 1) * V_CLKDIV2;
+            }
+        }
     }
     return nearestClock;
 }
@@ -160,67 +159,67 @@ xf86ModeStatusToString(ModeStatus status)
 {
     switch (status) {
     case MODE_OK:
-	return "Mode OK";
+        return "Mode OK";
     case MODE_HSYNC:
-	return "hsync out of range";
+        return "hsync out of range";
     case MODE_VSYNC:
-	return "vrefresh out of range";
+        return "vrefresh out of range";
     case MODE_H_ILLEGAL:
-	return "illegal horizontal timings";
+        return "illegal horizontal timings";
     case MODE_V_ILLEGAL:
-	return "illegal vertical timings";
+        return "illegal vertical timings";
     case MODE_BAD_WIDTH:
-	return "width requires unsupported line pitch";
+        return "width requires unsupported line pitch";
     case MODE_NOMODE:
-	return "no mode of this name";
+        return "no mode of this name";
     case MODE_NO_INTERLACE:
-	return "interlace mode not supported";
+        return "interlace mode not supported";
     case MODE_NO_DBLESCAN:
-	return "doublescan mode not supported";
+        return "doublescan mode not supported";
     case MODE_NO_VSCAN:
-	return "multiscan mode not supported";
+        return "multiscan mode not supported";
     case MODE_MEM:
-	return "insufficient memory for mode";
+        return "insufficient memory for mode";
     case MODE_VIRTUAL_X:
-	return "width too large for virtual size";
+        return "width too large for virtual size";
     case MODE_VIRTUAL_Y:
-	return "height too large for virtual size";
+        return "height too large for virtual size";
     case MODE_MEM_VIRT:
-	return "insufficient memory given virtual size";
+        return "insufficient memory given virtual size";
     case MODE_NOCLOCK:
-	return "no clock available for mode";
+        return "no clock available for mode";
     case MODE_CLOCK_HIGH:
-	return "mode clock too high";
+        return "mode clock too high";
     case MODE_CLOCK_LOW:
-	return "mode clock too low";
+        return "mode clock too low";
     case MODE_CLOCK_RANGE:
-	return "bad mode clock/interlace/doublescan";
+        return "bad mode clock/interlace/doublescan";
     case MODE_BAD_HVALUE:
-	return "horizontal timing out of range";
+        return "horizontal timing out of range";
     case MODE_BAD_VVALUE:
-	return "vertical timing out of range";
+        return "vertical timing out of range";
     case MODE_BAD_VSCAN:
-	return "VScan value out of range";
+        return "VScan value out of range";
     case MODE_HSYNC_NARROW:
-	return "horizontal sync too narrow";
+        return "horizontal sync too narrow";
     case MODE_HSYNC_WIDE:
-	return "horizontal sync too wide";
+        return "horizontal sync too wide";
     case MODE_HBLANK_NARROW:
-	return "horizontal blanking too narrow";
+        return "horizontal blanking too narrow";
     case MODE_HBLANK_WIDE:
-	return "horizontal blanking too wide";
+        return "horizontal blanking too wide";
     case MODE_VSYNC_NARROW:
-	return "vertical sync too narrow";
+        return "vertical sync too narrow";
     case MODE_VSYNC_WIDE:
-	return "vertical sync too wide";
+        return "vertical sync too wide";
     case MODE_VBLANK_NARROW:
-	return "vertical blanking too narrow";
+        return "vertical blanking too narrow";
     case MODE_VBLANK_WIDE:
-	return "vertical blanking too wide";
+        return "vertical blanking too wide";
     case MODE_PANEL:
-	return "exceeds panel dimensions";
+        return "exceeds panel dimensions";
     case MODE_INTERLACE_WIDTH:
-	return "width too large for interlaced mode";
+        return "width too large for interlaced mode";
     case MODE_ONE_WIDTH:
         return "all modes must have the same width";
     case MODE_ONE_HEIGHT:
@@ -230,13 +229,13 @@ xf86ModeStatusToString(ModeStatus status)
     case MODE_NO_REDUCED:
         return "monitor doesn't support reduced blanking";
     case MODE_BANDWIDTH:
-	return "mode requires too much memory bandwidth";
+        return "mode requires too much memory bandwidth";
     case MODE_BAD:
-	return "unknown reason";
+        return "unknown reason";
     case MODE_ERROR:
-	return "internal error";
+        return "internal error";
     default:
-	return "unknown";
+        return "unknown";
     }
 }
 
@@ -254,43 +253,46 @@ xf86ShowClockRanges(ScrnInfoPtr scrp, ClockRangePtr clockRanges)
     int scaledClock;
 
     for (cp = clockRanges; cp != NULL; cp = cp->next) {
-	DivFactor = max(1, cp->ClockDivFactor);
-	MulFactor = max(1, cp->ClockMulFactor);
-	if (scrp->progClock) {
-	    if (cp->minClock) {
-		if (cp->maxClock) {
-		    xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			"Clock range: %6.2f to %6.2f MHz\n",
-			(double)cp->minClock / 1000.0,
-			(double)cp->maxClock / 1000.0);
-		} else {
-		    xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			"Minimum clock: %6.2f MHz\n",
-			(double)cp->minClock / 1000.0);
-		}
-	    } else {
-		if (cp->maxClock) {
-		    xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			"Maximum clock: %6.2f MHz\n",
-			(double)cp->maxClock / 1000.0);
-		}
-	    }
-	} else if (DivFactor > 1 || MulFactor > 1) {
-	    j = 0;
-	    for (i = 0; i < scrp->numClocks; i++) {
-		scaledClock = (scrp->clock[i] * DivFactor) / MulFactor;
-		if (scaledClock >= cp->minClock && scaledClock <= cp->maxClock) {
-		    if ((j % 8) == 0) {
-			if (j > 0)
-			    xf86ErrorF("\n");
-			xf86DrvMsg(scrp->scrnIndex, X_INFO, "scaled clocks:");
-		    }
-		    xf86ErrorF(" %6.2f", (double)scaledClock / 1000.0);
-		    j++;
-		}
-	    }
-	    xf86ErrorF("\n");
-	}
+        DivFactor = max(1, cp->ClockDivFactor);
+        MulFactor = max(1, cp->ClockMulFactor);
+        if (scrp->progClock) {
+            if (cp->minClock) {
+                if (cp->maxClock) {
+                    xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                               "Clock range: %6.2f to %6.2f MHz\n",
+                               (double) cp->minClock / 1000.0,
+                               (double) cp->maxClock / 1000.0);
+                }
+                else {
+                    xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                               "Minimum clock: %6.2f MHz\n",
+                               (double) cp->minClock / 1000.0);
+                }
+            }
+            else {
+                if (cp->maxClock) {
+                    xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                               "Maximum clock: %6.2f MHz\n",
+                               (double) cp->maxClock / 1000.0);
+                }
+            }
+        }
+        else if (DivFactor > 1 || MulFactor > 1) {
+            j = 0;
+            for (i = 0; i < scrp->numClocks; i++) {
+                scaledClock = (scrp->clock[i] * DivFactor) / MulFactor;
+                if (scaledClock >= cp->minClock && scaledClock <= cp->maxClock) {
+                    if ((j % 8) == 0) {
+                        if (j > 0)
+                            xf86ErrorF("\n");
+                        xf86DrvMsg(scrp->scrnIndex, X_INFO, "scaled clocks:");
+                    }
+                    xf86ErrorF(" %6.2f", (double) scaledClock / 1000.0);
+                    j++;
+                }
+            }
+            xf86ErrorF("\n");
+        }
     }
 }
 
@@ -298,10 +300,10 @@ static Bool
 modeInClockRange(ClockRangePtr cp, DisplayModePtr p)
 {
     return ((p->Clock >= cp->minClock) &&
-	    (p->Clock <= cp->maxClock) &&
-	    (cp->interlaceAllowed || !(p->Flags & V_INTERLACE)) &&
-	    (cp->doubleScanAllowed ||
-	     ((p->VScan <= 1) && !(p->Flags & V_DBLSCAN))));
+            (p->Clock <= cp->maxClock) &&
+            (cp->interlaceAllowed || !(p->Flags & V_INTERLACE)) &&
+            (cp->doubleScanAllowed ||
+             ((p->VScan <= 1) && !(p->Flags & V_DBLSCAN))));
 }
 
 /*
@@ -312,111 +314,112 @@ xf86FindClockRangeForMode(ClockRangePtr clockRanges, DisplayModePtr p)
 {
     ClockRangePtr cp;
 
-    for (cp = clockRanges; ; cp = cp->next)
-	if (!cp || modeInClockRange(cp, p))
-	    return cp;
+    for (cp = clockRanges;; cp = cp->next)
+        if (!cp || modeInClockRange(cp, p))
+            return cp;
 }
 
-
 /*
  * xf86HandleBuiltinMode() - handles built-in modes
  */
 static ModeStatus
 xf86HandleBuiltinMode(ScrnInfoPtr scrp,
-		      DisplayModePtr p,
-		      DisplayModePtr modep,
-		      ClockRangePtr clockRanges,
-		      Bool allowDiv2)
+                      DisplayModePtr p,
+                      DisplayModePtr modep,
+                      ClockRangePtr clockRanges, Bool allowDiv2)
 {
     ClockRangePtr cp;
     int extraFlags = 0;
     int MulFactor = 1;
     int DivFactor = 1;
     int clockIndex;
-    
+
     /* Reject previously rejected modes */
     if (p->status != MODE_OK)
-	return p->status;
+        return p->status;
 
     /* Reject previously considered modes */
     if (p->prev)
         return MODE_NOMODE;
 
     if ((p->type & M_T_CLOCK_C) == M_T_CLOCK_C) {
-	/* Check clock is in range */
-	cp = xf86FindClockRangeForMode(clockRanges, p);
-	if (cp == NULL){
-	    modep->type = p->type;
-	    p->status = MODE_CLOCK_RANGE;
-	    return MODE_CLOCK_RANGE;
-	}
-	DivFactor = cp->ClockDivFactor;
-	MulFactor = cp->ClockMulFactor;
-	if (!scrp->progClock) {
-	    clockIndex = xf86GetNearestClock(scrp, p->Clock, allowDiv2,
-					     cp->ClockDivFactor,
-					     cp->ClockMulFactor, &extraFlags);
-	    modep->Clock = (scrp->clock[clockIndex] * DivFactor)
-		/ MulFactor;
-	    modep->ClockIndex	= clockIndex;
-	    modep->SynthClock	= scrp->clock[clockIndex];
-	    if (extraFlags & V_CLKDIV2) {
-		modep->Clock /= 2;
-		modep->SynthClock /= 2;
-	    }
-	} else {
-	    modep->Clock = p->Clock;
-	    modep->ClockIndex = -1;
-	    modep->SynthClock = (modep->Clock * MulFactor)
-		/ DivFactor;
-	}
-	modep->PrivFlags = cp->PrivFlags;
-    } else {
-	if(!scrp->progClock) {
+        /* Check clock is in range */
+        cp = xf86FindClockRangeForMode(clockRanges, p);
+        if (cp == NULL) {
+            modep->type = p->type;
+            p->status = MODE_CLOCK_RANGE;
+            return MODE_CLOCK_RANGE;
+        }
+        DivFactor = cp->ClockDivFactor;
+        MulFactor = cp->ClockMulFactor;
+        if (!scrp->progClock) {
+            clockIndex = xf86GetNearestClock(scrp, p->Clock, allowDiv2,
+                                             cp->ClockDivFactor,
+                                             cp->ClockMulFactor, &extraFlags);
+            modep->Clock = (scrp->clock[clockIndex] * DivFactor)
+                / MulFactor;
+            modep->ClockIndex = clockIndex;
+            modep->SynthClock = scrp->clock[clockIndex];
+            if (extraFlags & V_CLKDIV2) {
+                modep->Clock /= 2;
+                modep->SynthClock /= 2;
+            }
+        }
+        else {
             modep->Clock = p->Clock;
-	    modep->ClockIndex = p->ClockIndex;
-	    modep->SynthClock = p->SynthClock;
-	} else {
-	    modep->Clock = p->Clock;
-	    modep->ClockIndex = -1;
-	    modep->SynthClock = p->SynthClock;
-	}
-	modep->PrivFlags = p->PrivFlags;
+            modep->ClockIndex = -1;
+            modep->SynthClock = (modep->Clock * MulFactor)
+                / DivFactor;
+        }
+        modep->PrivFlags = cp->PrivFlags;
     }
-    modep->type            = p->type;
-    modep->HDisplay        = p->HDisplay;
-    modep->HSyncStart      = p->HSyncStart;
-    modep->HSyncEnd        = p->HSyncEnd;
-    modep->HTotal          = p->HTotal;
-    modep->HSkew           = p->HSkew;
-    modep->VDisplay        = p->VDisplay;
-    modep->VSyncStart      = p->VSyncStart;
-    modep->VSyncEnd        = p->VSyncEnd;
-    modep->VTotal          = p->VTotal;
-    modep->VScan           = p->VScan;
-    modep->Flags           = p->Flags | extraFlags;
-    modep->CrtcHDisplay    = p->CrtcHDisplay;
+    else {
+        if (!scrp->progClock) {
+            modep->Clock = p->Clock;
+            modep->ClockIndex = p->ClockIndex;
+            modep->SynthClock = p->SynthClock;
+        }
+        else {
+            modep->Clock = p->Clock;
+            modep->ClockIndex = -1;
+            modep->SynthClock = p->SynthClock;
+        }
+        modep->PrivFlags = p->PrivFlags;
+    }
+    modep->type = p->type;
+    modep->HDisplay = p->HDisplay;
+    modep->HSyncStart = p->HSyncStart;
+    modep->HSyncEnd = p->HSyncEnd;
+    modep->HTotal = p->HTotal;
+    modep->HSkew = p->HSkew;
+    modep->VDisplay = p->VDisplay;
+    modep->VSyncStart = p->VSyncStart;
+    modep->VSyncEnd = p->VSyncEnd;
+    modep->VTotal = p->VTotal;
+    modep->VScan = p->VScan;
+    modep->Flags = p->Flags | extraFlags;
+    modep->CrtcHDisplay = p->CrtcHDisplay;
     modep->CrtcHBlankStart = p->CrtcHBlankStart;
-    modep->CrtcHSyncStart  = p->CrtcHSyncStart;
-    modep->CrtcHSyncEnd    = p->CrtcHSyncEnd;
-    modep->CrtcHBlankEnd   = p->CrtcHBlankEnd;
-    modep->CrtcHTotal      = p->CrtcHTotal;
-    modep->CrtcHSkew       = p->CrtcHSkew;
-    modep->CrtcVDisplay    = p->CrtcVDisplay;
+    modep->CrtcHSyncStart = p->CrtcHSyncStart;
+    modep->CrtcHSyncEnd = p->CrtcHSyncEnd;
+    modep->CrtcHBlankEnd = p->CrtcHBlankEnd;
+    modep->CrtcHTotal = p->CrtcHTotal;
+    modep->CrtcHSkew = p->CrtcHSkew;
+    modep->CrtcVDisplay = p->CrtcVDisplay;
     modep->CrtcVBlankStart = p->CrtcVBlankStart;
-    modep->CrtcVSyncStart  = p->CrtcVSyncStart;
-    modep->CrtcVSyncEnd    = p->CrtcVSyncEnd;
-    modep->CrtcVBlankEnd   = p->CrtcVBlankEnd;
-    modep->CrtcVTotal      = p->CrtcVTotal;
-    modep->CrtcHAdjusted   = p->CrtcHAdjusted;
-    modep->CrtcVAdjusted   = p->CrtcVAdjusted;
-    modep->HSync           = p->HSync;
-    modep->VRefresh        = p->VRefresh;
-    modep->Private         = p->Private;
-    modep->PrivSize        = p->PrivSize;
+    modep->CrtcVSyncStart = p->CrtcVSyncStart;
+    modep->CrtcVSyncEnd = p->CrtcVSyncEnd;
+    modep->CrtcVBlankEnd = p->CrtcVBlankEnd;
+    modep->CrtcVTotal = p->CrtcVTotal;
+    modep->CrtcHAdjusted = p->CrtcHAdjusted;
+    modep->CrtcVAdjusted = p->CrtcVAdjusted;
+    modep->HSync = p->HSync;
+    modep->VRefresh = p->VRefresh;
+    modep->Private = p->Private;
+    modep->PrivSize = p->PrivSize;
 
     p->prev = modep;
-    
+
     return MODE_OK;
 }
 
@@ -450,7 +453,7 @@ xf86HandleBuiltinMode(ScrnInfoPtr scrp,
 
 ModeStatus
 xf86LookupMode(ScrnInfoPtr scrp, DisplayModePtr modep,
-	       ClockRangePtr clockRanges, LookupModeFlags strategy)
+               ClockRangePtr clockRanges, LookupModeFlags strategy)
 {
     DisplayModePtr p, bestMode = NULL;
     ClockRangePtr cp;
@@ -465,14 +468,15 @@ xf86LookupMode(ScrnInfoPtr scrp, DisplayModePtr modep,
     ModeStatus status = MODE_NOMODE;
     Bool allowDiv2 = (strategy & LOOKUP_CLKDIV2) != 0;
     int n;
+
     const int types[] = {
-	M_T_BUILTIN | M_T_PREFERRED,
-	M_T_BUILTIN,
-	M_T_USERDEF | M_T_PREFERRED,
-	M_T_USERDEF,
-	M_T_DRIVER | M_T_PREFERRED,
-	M_T_DRIVER,
-	0
+        M_T_BUILTIN | M_T_PREFERRED,
+        M_T_BUILTIN,
+        M_T_USERDEF | M_T_PREFERRED,
+        M_T_USERDEF,
+        M_T_DRIVER | M_T_PREFERRED,
+        M_T_DRIVER,
+        0
     };
     const int ntypes = sizeof(types) / sizeof(int);
 
@@ -480,206 +484,209 @@ xf86LookupMode(ScrnInfoPtr scrp, DisplayModePtr modep,
 
     /* Some sanity checking */
     if (scrp == NULL || scrp->modePool == NULL ||
-	(!scrp->progClock && scrp->numClocks == 0)) {
-	ErrorF("xf86LookupMode: called with invalid scrnInfoRec\n");
-	return MODE_ERROR;
+        (!scrp->progClock && scrp->numClocks == 0)) {
+        ErrorF("xf86LookupMode: called with invalid scrnInfoRec\n");
+        return MODE_ERROR;
     }
     if (modep == NULL || modep->name == NULL) {
-	ErrorF("xf86LookupMode: called with invalid modep\n");
-	return MODE_ERROR;
+        ErrorF("xf86LookupMode: called with invalid modep\n");
+        return MODE_ERROR;
     }
     for (cp = clockRanges; cp != NULL; cp = cp->next) {
-	/* DivFactor and MulFactor must be > 0 */
-	cp->ClockDivFactor = max(1, cp->ClockDivFactor);
-	cp->ClockMulFactor = max(1, cp->ClockMulFactor);
+        /* DivFactor and MulFactor must be > 0 */
+        cp->ClockDivFactor = max(1, cp->ClockDivFactor);
+        cp->ClockMulFactor = max(1, cp->ClockMulFactor);
     }
 
     /* Scan the mode pool for matching names */
     for (n = 0; n < ntypes; n++) {
-	int type = types[n];
-	for (p = scrp->modePool; p != NULL; p = p->next) {
-
-	    /* scan through the modes in the sort order above */
-	    if ((p->type & type) != type)
-		continue;
-
-	    if (strcmp(p->name, modep->name) == 0) {
-
-		/* Skip over previously rejected modes */
-		if (p->status != MODE_OK) {
-		    if (!found)
-			status = p->status;
-		    continue;
-		}
-
-		/* Skip over previously considered modes */
-		if (p->prev)
-		    continue;
-
-		if (p->type & M_T_BUILTIN) {
-		    return xf86HandleBuiltinMode(scrp, p,modep, clockRanges,
-			    allowDiv2);
-		}
-
-		/* Check clock is in range */
-		cp = xf86FindClockRangeForMode(clockRanges, p);
-		if (cp == NULL) {
-		    /*
-		     * XXX Could do more here to provide a more detailed
-		     * reason for not finding a mode.
-		     */
-		    p->status = MODE_CLOCK_RANGE;
-		    if (!found)
-			status = MODE_CLOCK_RANGE;
-		    continue;
-		}
-
-		/*
-		 * If programmable clock and strategy is not
-		 * LOOKUP_BEST_REFRESH, the required mode has been found,
-		 * otherwise record the refresh and continue looking.
-		 */
-		if (scrp->progClock) {
-		    found = TRUE;
-		    if (strategy != LOOKUP_BEST_REFRESH) {
-			bestMode = p;
-			DivFactor = cp->ClockDivFactor;
-			MulFactor = cp->ClockMulFactor;
-			ModePrivFlags = cp->PrivFlags;
-			break;
-		    }
-		    refresh = xf86ModeVRefresh(p);
-		    if (p->Flags & V_INTERLACE)
-			refresh /= INTERLACE_REFRESH_WEIGHT;
-		    if (refresh > bestRefresh) {
-			bestMode = p;
-			DivFactor = cp->ClockDivFactor;
-			MulFactor = cp->ClockMulFactor;
-			ModePrivFlags = cp->PrivFlags;
-			bestRefresh = refresh;
-		    }
-		    continue;
-		}
-
-		/*
-		 * Clock is in range, so if it is not a programmable clock, find
-		 * a matching clock.
-		 */
-
-		i = xf86GetNearestClock(scrp, p->Clock, allowDiv2,
-			cp->ClockDivFactor, cp->ClockMulFactor, &k);
-		/*
-		 * If the clock is too far from the requested clock, this
-		 * mode is no good.
-		 */
-		if (k & V_CLKDIV2)
-		    gap = abs((p->Clock * 2) -
-			    ((scrp->clock[i] * cp->ClockDivFactor) /
-				cp->ClockMulFactor));
-		else
-		    gap = abs(p->Clock -
-			    ((scrp->clock[i] * cp->ClockDivFactor) /
-				cp->ClockMulFactor));
-		if (gap > minimumGap) {
-		    p->status = MODE_NOCLOCK;
-		    if (!found)
-			status = MODE_NOCLOCK;
-		    continue;
-		}
-		found = TRUE;
-
-		if (strategy == LOOKUP_BEST_REFRESH) {
-		    refresh = xf86ModeVRefresh(p);
-		    if (p->Flags & V_INTERLACE)
-			refresh /= INTERLACE_REFRESH_WEIGHT;
-		    if (refresh > bestRefresh) {
-			bestMode = p;
-			DivFactor = cp->ClockDivFactor;
-			MulFactor = cp->ClockMulFactor;
-			ModePrivFlags = cp->PrivFlags;
-			extraFlags = k;
-			clockIndex = i;
-			bestRefresh = refresh;
-		    }
-		    continue;
-		}
-		if (strategy == LOOKUP_CLOSEST_CLOCK) {
-		    if (gap < minimumGap) {
-			bestMode = p;
-			DivFactor = cp->ClockDivFactor;
-			MulFactor = cp->ClockMulFactor;
-			ModePrivFlags = cp->PrivFlags;
-			extraFlags = k;
-			clockIndex = i;
-			minimumGap = gap;
-		    }
-		    continue;
-		}
-		/*
-		 * If strategy is neither LOOKUP_BEST_REFRESH or
-		 * LOOKUP_CLOSEST_CLOCK the required mode has been found.
-		 */
-		bestMode = p;
-		DivFactor = cp->ClockDivFactor;
-		MulFactor = cp->ClockMulFactor;
-		ModePrivFlags = cp->PrivFlags;
-		extraFlags = k;
-		clockIndex = i;
-		break;
-	    }
-	}
-	if (found) break;
+        int type = types[n];
+
+        for (p = scrp->modePool; p != NULL; p = p->next) {
+
+            /* scan through the modes in the sort order above */
+            if ((p->type & type) != type)
+                continue;
+
+            if (strcmp(p->name, modep->name) == 0) {
+
+                /* Skip over previously rejected modes */
+                if (p->status != MODE_OK) {
+                    if (!found)
+                        status = p->status;
+                    continue;
+                }
+
+                /* Skip over previously considered modes */
+                if (p->prev)
+                    continue;
+
+                if (p->type & M_T_BUILTIN) {
+                    return xf86HandleBuiltinMode(scrp, p, modep, clockRanges,
+                                                 allowDiv2);
+                }
+
+                /* Check clock is in range */
+                cp = xf86FindClockRangeForMode(clockRanges, p);
+                if (cp == NULL) {
+                    /*
+                     * XXX Could do more here to provide a more detailed
+                     * reason for not finding a mode.
+                     */
+                    p->status = MODE_CLOCK_RANGE;
+                    if (!found)
+                        status = MODE_CLOCK_RANGE;
+                    continue;
+                }
+
+                /*
+                 * If programmable clock and strategy is not
+                 * LOOKUP_BEST_REFRESH, the required mode has been found,
+                 * otherwise record the refresh and continue looking.
+                 */
+                if (scrp->progClock) {
+                    found = TRUE;
+                    if (strategy != LOOKUP_BEST_REFRESH) {
+                        bestMode = p;
+                        DivFactor = cp->ClockDivFactor;
+                        MulFactor = cp->ClockMulFactor;
+                        ModePrivFlags = cp->PrivFlags;
+                        break;
+                    }
+                    refresh = xf86ModeVRefresh(p);
+                    if (p->Flags & V_INTERLACE)
+                        refresh /= INTERLACE_REFRESH_WEIGHT;
+                    if (refresh > bestRefresh) {
+                        bestMode = p;
+                        DivFactor = cp->ClockDivFactor;
+                        MulFactor = cp->ClockMulFactor;
+                        ModePrivFlags = cp->PrivFlags;
+                        bestRefresh = refresh;
+                    }
+                    continue;
+                }
+
+                /*
+                 * Clock is in range, so if it is not a programmable clock, find
+                 * a matching clock.
+                 */
+
+                i = xf86GetNearestClock(scrp, p->Clock, allowDiv2,
+                                        cp->ClockDivFactor, cp->ClockMulFactor,
+                                        &k);
+                /*
+                 * If the clock is too far from the requested clock, this
+                 * mode is no good.
+                 */
+                if (k & V_CLKDIV2)
+                    gap = abs((p->Clock * 2) -
+                              ((scrp->clock[i] * cp->ClockDivFactor) /
+                               cp->ClockMulFactor));
+                else
+                    gap = abs(p->Clock -
+                              ((scrp->clock[i] * cp->ClockDivFactor) /
+                               cp->ClockMulFactor));
+                if (gap > minimumGap) {
+                    p->status = MODE_NOCLOCK;
+                    if (!found)
+                        status = MODE_NOCLOCK;
+                    continue;
+                }
+                found = TRUE;
+
+                if (strategy == LOOKUP_BEST_REFRESH) {
+                    refresh = xf86ModeVRefresh(p);
+                    if (p->Flags & V_INTERLACE)
+                        refresh /= INTERLACE_REFRESH_WEIGHT;
+                    if (refresh > bestRefresh) {
+                        bestMode = p;
+                        DivFactor = cp->ClockDivFactor;
+                        MulFactor = cp->ClockMulFactor;
+                        ModePrivFlags = cp->PrivFlags;
+                        extraFlags = k;
+                        clockIndex = i;
+                        bestRefresh = refresh;
+                    }
+                    continue;
+                }
+                if (strategy == LOOKUP_CLOSEST_CLOCK) {
+                    if (gap < minimumGap) {
+                        bestMode = p;
+                        DivFactor = cp->ClockDivFactor;
+                        MulFactor = cp->ClockMulFactor;
+                        ModePrivFlags = cp->PrivFlags;
+                        extraFlags = k;
+                        clockIndex = i;
+                        minimumGap = gap;
+                    }
+                    continue;
+                }
+                /*
+                 * If strategy is neither LOOKUP_BEST_REFRESH or
+                 * LOOKUP_CLOSEST_CLOCK the required mode has been found.
+                 */
+                bestMode = p;
+                DivFactor = cp->ClockDivFactor;
+                MulFactor = cp->ClockMulFactor;
+                ModePrivFlags = cp->PrivFlags;
+                extraFlags = k;
+                clockIndex = i;
+                break;
+            }
+        }
+        if (found)
+            break;
     }
     if (!found || bestMode == NULL)
-	return status;
+        return status;
 
     /* Fill in the mode parameters */
     if (scrp->progClock) {
-        modep->Clock		= bestMode->Clock;
-	modep->ClockIndex	= -1;
-	modep->SynthClock	= (modep->Clock * MulFactor) / DivFactor;
-    } else {
-	modep->Clock		= (scrp->clock[clockIndex] * DivFactor) /
-				    MulFactor;
-	modep->ClockIndex	= clockIndex;
-	modep->SynthClock	= scrp->clock[clockIndex];
-	if (extraFlags & V_CLKDIV2) {
-	    modep->Clock /= 2;
-	    modep->SynthClock /= 2;
-	}
+        modep->Clock = bestMode->Clock;
+        modep->ClockIndex = -1;
+        modep->SynthClock = (modep->Clock * MulFactor) / DivFactor;
+    }
+    else {
+        modep->Clock = (scrp->clock[clockIndex] * DivFactor) / MulFactor;
+        modep->ClockIndex = clockIndex;
+        modep->SynthClock = scrp->clock[clockIndex];
+        if (extraFlags & V_CLKDIV2) {
+            modep->Clock /= 2;
+            modep->SynthClock /= 2;
+        }
     }
-    modep->type                 = bestMode->type;
-    modep->PrivFlags		= ModePrivFlags;
-    modep->HDisplay		= bestMode->HDisplay;
-    modep->HSyncStart		= bestMode->HSyncStart;
-    modep->HSyncEnd		= bestMode->HSyncEnd;
-    modep->HTotal		= bestMode->HTotal;
-    modep->HSkew		= bestMode->HSkew;
-    modep->VDisplay		= bestMode->VDisplay;
-    modep->VSyncStart		= bestMode->VSyncStart;
-    modep->VSyncEnd		= bestMode->VSyncEnd;
-    modep->VTotal		= bestMode->VTotal;
-    modep->VScan		= bestMode->VScan;
-    modep->Flags		= bestMode->Flags | extraFlags;
-    modep->CrtcHDisplay		= bestMode->CrtcHDisplay;
-    modep->CrtcHBlankStart	= bestMode->CrtcHBlankStart;
-    modep->CrtcHSyncStart	= bestMode->CrtcHSyncStart;
-    modep->CrtcHSyncEnd		= bestMode->CrtcHSyncEnd;
-    modep->CrtcHBlankEnd	= bestMode->CrtcHBlankEnd;
-    modep->CrtcHTotal		= bestMode->CrtcHTotal;
-    modep->CrtcHSkew		= bestMode->CrtcHSkew;
-    modep->CrtcVDisplay		= bestMode->CrtcVDisplay;
-    modep->CrtcVBlankStart	= bestMode->CrtcVBlankStart;
-    modep->CrtcVSyncStart	= bestMode->CrtcVSyncStart;
-    modep->CrtcVSyncEnd		= bestMode->CrtcVSyncEnd;
-    modep->CrtcVBlankEnd	= bestMode->CrtcVBlankEnd;
-    modep->CrtcVTotal		= bestMode->CrtcVTotal;
-    modep->CrtcHAdjusted	= bestMode->CrtcHAdjusted;
-    modep->CrtcVAdjusted	= bestMode->CrtcVAdjusted;
-    modep->HSync		= bestMode->HSync;
-    modep->VRefresh		= bestMode->VRefresh;
-    modep->Private		= bestMode->Private;
-    modep->PrivSize		= bestMode->PrivSize;
+    modep->type = bestMode->type;
+    modep->PrivFlags = ModePrivFlags;
+    modep->HDisplay = bestMode->HDisplay;
+    modep->HSyncStart = bestMode->HSyncStart;
+    modep->HSyncEnd = bestMode->HSyncEnd;
+    modep->HTotal = bestMode->HTotal;
+    modep->HSkew = bestMode->HSkew;
+    modep->VDisplay = bestMode->VDisplay;
+    modep->VSyncStart = bestMode->VSyncStart;
+    modep->VSyncEnd = bestMode->VSyncEnd;
+    modep->VTotal = bestMode->VTotal;
+    modep->VScan = bestMode->VScan;
+    modep->Flags = bestMode->Flags | extraFlags;
+    modep->CrtcHDisplay = bestMode->CrtcHDisplay;
+    modep->CrtcHBlankStart = bestMode->CrtcHBlankStart;
+    modep->CrtcHSyncStart = bestMode->CrtcHSyncStart;
+    modep->CrtcHSyncEnd = bestMode->CrtcHSyncEnd;
+    modep->CrtcHBlankEnd = bestMode->CrtcHBlankEnd;
+    modep->CrtcHTotal = bestMode->CrtcHTotal;
+    modep->CrtcHSkew = bestMode->CrtcHSkew;
+    modep->CrtcVDisplay = bestMode->CrtcVDisplay;
+    modep->CrtcVBlankStart = bestMode->CrtcVBlankStart;
+    modep->CrtcVSyncStart = bestMode->CrtcVSyncStart;
+    modep->CrtcVSyncEnd = bestMode->CrtcVSyncEnd;
+    modep->CrtcVBlankEnd = bestMode->CrtcVBlankEnd;
+    modep->CrtcVTotal = bestMode->CrtcVTotal;
+    modep->CrtcHAdjusted = bestMode->CrtcHAdjusted;
+    modep->CrtcVAdjusted = bestMode->CrtcVAdjusted;
+    modep->HSync = bestMode->HSync;
+    modep->VRefresh = bestMode->VRefresh;
+    modep->Private = bestMode->Private;
+    modep->PrivSize = bestMode->PrivSize;
 
     bestMode->prev = modep;
 
@@ -699,51 +706,53 @@ xf86CheckModeForMonitor(DisplayModePtr mode, MonPtr monitor)
 
     /* Sanity checks */
     if (mode == NULL || monitor == NULL) {
-	ErrorF("xf86CheckModeForMonitor: called with invalid parameters\n");
-	return MODE_ERROR;
+        ErrorF("xf86CheckModeForMonitor: called with invalid parameters\n");
+        return MODE_ERROR;
     }
 
     DebugF("xf86CheckModeForMonitor(%p %s, %p %s)\n",
-	   mode, mode->name, monitor, monitor->id);
+           mode, mode->name, monitor, monitor->id);
 
     /* Some basic mode validity checks */
     if (0 >= mode->HDisplay || mode->HDisplay > mode->HSyncStart ||
-	mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
-	return MODE_H_ILLEGAL;
+        mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
+        return MODE_H_ILLEGAL;
 
     if (0 >= mode->VDisplay || mode->VDisplay > mode->VSyncStart ||
-	mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
-	return MODE_V_ILLEGAL;
+        mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
+        return MODE_V_ILLEGAL;
 
     if (monitor->nHsync > 0) {
-	/* Check hsync against the allowed ranges */
-	float hsync = xf86ModeHSync(mode);
-	for (i = 0; i < monitor->nHsync; i++) 
-	    if ((hsync > monitor->hsync[i].lo * (1.0 - SYNC_TOLERANCE)) &&
-		(hsync < monitor->hsync[i].hi * (1.0 + SYNC_TOLERANCE)))
-		break;
-	
-	/* Now see whether we ran out of sync ranges without finding a match */
-	if (i == monitor->nHsync) 
-	    return MODE_HSYNC;
+        /* Check hsync against the allowed ranges */
+        float hsync = xf86ModeHSync(mode);
+
+        for (i = 0; i < monitor->nHsync; i++)
+            if ((hsync > monitor->hsync[i].lo * (1.0 - SYNC_TOLERANCE)) &&
+                (hsync < monitor->hsync[i].hi * (1.0 + SYNC_TOLERANCE)))
+                break;
+
+        /* Now see whether we ran out of sync ranges without finding a match */
+        if (i == monitor->nHsync)
+            return MODE_HSYNC;
     }
 
     if (monitor->nVrefresh > 0) {
-	/* Check vrefresh against the allowed ranges */
-	float vrefrsh = xf86ModeVRefresh(mode);
-	for (i = 0; i < monitor->nVrefresh; i++)
-	    if ((vrefrsh > monitor->vrefresh[i].lo * (1.0 - SYNC_TOLERANCE)) &&
-		(vrefrsh < monitor->vrefresh[i].hi * (1.0 + SYNC_TOLERANCE)))
-		break;
-
-	/* Now see whether we ran out of refresh ranges without finding a match */
-	if (i == monitor->nVrefresh)
-	    return MODE_VSYNC;
+        /* Check vrefresh against the allowed ranges */
+        float vrefrsh = xf86ModeVRefresh(mode);
+
+        for (i = 0; i < monitor->nVrefresh; i++)
+            if ((vrefrsh > monitor->vrefresh[i].lo * (1.0 - SYNC_TOLERANCE)) &&
+                (vrefrsh < monitor->vrefresh[i].hi * (1.0 + SYNC_TOLERANCE)))
+                break;
+
+        /* Now see whether we ran out of refresh ranges without finding a match */
+        if (i == monitor->nVrefresh)
+            return MODE_VSYNC;
     }
 
     /* Force interlaced modes to have an odd VTotal */
     if (mode->Flags & V_INTERLACE)
-	mode->CrtcVTotal = mode->VTotal |= 1;
+        mode->CrtcVTotal = mode->VTotal |= 1;
 
     /*
      * This code stops cvt -r modes, and only cvt -r modes, from hitting 15y+
@@ -759,7 +768,7 @@ xf86CheckModeForMonitor(DisplayModePtr mode, MonPtr monitor)
     }
 
     if ((monitor->maxPixClock) && (mode->Clock > monitor->maxPixClock))
-	return MODE_CLOCK_HIGH;
+        return MODE_CLOCK_HIGH;
 
     return MODE_OK;
 }
@@ -774,16 +783,15 @@ xf86CheckModeForMonitor(DisplayModePtr mode, MonPtr monitor)
 static Bool
 xf86CheckModeSize(ScrnInfoPtr scrp, int w, int x, int y)
 {
-    int bpp = scrp->fbFormat.bitsPerPixel,
-	pad = scrp->fbFormat.scanlinePad;
+    int bpp = scrp->fbFormat.bitsPerPixel, pad = scrp->fbFormat.scanlinePad;
     int lineWidth, lastWidth;
 
     if (scrp->depth == 4)
-	pad *= 4;		/* 4 planes */
+        pad *= 4;               /* 4 planes */
 
     /* Sanity check */
     if ((w < 0) || (x < 0) || (y <= 0))
-	return FALSE;
+        return FALSE;
 
     lineWidth = (((w * bpp) + pad - 1) / pad) * pad;
     lastWidth = x * bpp;
@@ -791,11 +799,11 @@ xf86CheckModeSize(ScrnInfoPtr scrp, int w, int x, int y)
     /*
      * At this point, we need to compare
      *
-     *	(lineWidth * (y - 1)) + lastWidth
+     *  (lineWidth * (y - 1)) + lastWidth
      *
      * against
      *
-     *	scrp->videoRam * (1024 * 8)
+     *  scrp->videoRam * (1024 * 8)
      *
      * These are bit quantities.  To avoid overflows, do the comparison in
      * terms of BITMAP_SCANLINE_PAD units.  This assumes BITMAP_SCANLINE_PAD
@@ -807,8 +815,8 @@ xf86CheckModeSize(ScrnInfoPtr scrp, int w, int x, int y)
     lastWidth = (lastWidth + (BITMAP_SCANLINE_PAD - 1)) / BITMAP_SCANLINE_PAD;
 
     if ((lineWidth * (y - 1) + lastWidth) >
-	(scrp->videoRam * ((1024 * 8) / BITMAP_SCANLINE_PAD)))
-	return FALSE;
+        (scrp->videoRam * ((1024 * 8) / BITMAP_SCANLINE_PAD)))
+        return FALSE;
 
     return TRUE;
 }
@@ -839,52 +847,53 @@ xf86CheckModeSize(ScrnInfoPtr scrp, int w, int x, int y)
 
 ModeStatus
 xf86InitialCheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode,
-			      ClockRangePtr clockRanges,
-			      LookupModeFlags strategy,
-			      int maxPitch, int virtualX, int virtualY)
+                              ClockRangePtr clockRanges,
+                              LookupModeFlags strategy,
+                              int maxPitch, int virtualX, int virtualY)
 {
     ClockRangePtr cp;
     ModeStatus status;
     Bool allowDiv2 = (strategy & LOOKUP_CLKDIV2) != 0;
     int i, needDiv2;
-    
+
     /* Sanity checks */
     if (!scrp || !mode || !clockRanges) {
-	ErrorF("xf86InitialCheckModeForDriver: "
-		"called with invalid parameters\n");
-	return MODE_ERROR;
+        ErrorF("xf86InitialCheckModeForDriver: "
+               "called with invalid parameters\n");
+        return MODE_ERROR;
     }
 
     DebugF("xf86InitialCheckModeForDriver(%p, %p %s, %p, 0x%x, %d, %d, %d)\n",
-	   scrp, mode, mode->name , clockRanges, strategy, maxPitch,  virtualX, virtualY);
+           scrp, mode, mode->name, clockRanges, strategy, maxPitch, virtualX,
+           virtualY);
 
     /* Some basic mode validity checks */
     if (0 >= mode->HDisplay || mode->HDisplay > mode->HSyncStart ||
-	mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
-	return MODE_H_ILLEGAL;
+        mode->HSyncStart >= mode->HSyncEnd || mode->HSyncEnd >= mode->HTotal)
+        return MODE_H_ILLEGAL;
 
     if (0 >= mode->VDisplay || mode->VDisplay > mode->VSyncStart ||
-	mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
-	return MODE_V_ILLEGAL;
+        mode->VSyncStart >= mode->VSyncEnd || mode->VSyncEnd >= mode->VTotal)
+        return MODE_V_ILLEGAL;
 
     if (!xf86CheckModeSize(scrp, mode->HDisplay, mode->HDisplay,
-				 mode->VDisplay))
+                           mode->VDisplay))
         return MODE_MEM;
 
     if (maxPitch > 0 && mode->HDisplay > maxPitch)
-	return MODE_BAD_WIDTH;
+        return MODE_BAD_WIDTH;
 
     if (virtualX > 0 && mode->HDisplay > virtualX)
-	return MODE_VIRTUAL_X;
+        return MODE_VIRTUAL_X;
 
     if (virtualY > 0 && mode->VDisplay > virtualY)
-	return MODE_VIRTUAL_Y;
+        return MODE_VIRTUAL_Y;
 
     if (scrp->maxHValue > 0 && mode->HTotal > scrp->maxHValue)
-	return MODE_BAD_HVALUE;
+        return MODE_BAD_HVALUE;
 
     if (scrp->maxVValue > 0 && mode->VTotal > scrp->maxVValue)
-	return MODE_BAD_VVALUE;
+        return MODE_BAD_VVALUE;
 
     /*
      * The use of the DisplayModeRec's Crtc* and SynthClock elements below is
@@ -910,48 +919,49 @@ xf86InitialCheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode,
      * confusion and is bad software design. However since it's part of
      * the driver API it's hard to change.
      */
-     
+
     if (scrp->ValidMode) {
-	
-	xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
-
-	cp = xf86FindClockRangeForMode(clockRanges, mode);
-	if (!cp)
-	    return MODE_CLOCK_RANGE;
-
-	if (cp->ClockMulFactor < 1)
-	    cp->ClockMulFactor = 1;
-	if (cp->ClockDivFactor < 1)
-	    cp->ClockDivFactor = 1;
-	
-	/*
-	 * XXX  The effect of clock dividers and multipliers on the monitor's
-	 *      pixel clock needs to be verified.
-	 */
-	if (scrp->progClock) {
-	    mode->SynthClock = mode->Clock;
-	} else {
-	    i = xf86GetNearestClock(scrp, mode->Clock, allowDiv2,
-				    cp->ClockDivFactor, cp->ClockMulFactor,
-				    &needDiv2);
-	    mode->SynthClock = (scrp->clock[i] * cp->ClockDivFactor) /
-		cp->ClockMulFactor;
-	    if (needDiv2 & V_CLKDIV2)
-		mode->SynthClock /= 2;
-	}
-
-	status = (*scrp->ValidMode)(scrp->scrnIndex, mode, FALSE,
-				    MODECHECK_INITIAL);
-	if (status != MODE_OK)
-	    return status;
-
-	if (mode->HSync <= 0.0)
-	    mode->HSync = (float)mode->SynthClock / (float)mode->CrtcHTotal;
-	if (mode->VRefresh <= 0.0)
-	    mode->VRefresh = (mode->SynthClock * 1000.0)
-		/ (mode->CrtcHTotal * mode->CrtcVTotal);
+
+        xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
+
+        cp = xf86FindClockRangeForMode(clockRanges, mode);
+        if (!cp)
+            return MODE_CLOCK_RANGE;
+
+        if (cp->ClockMulFactor < 1)
+            cp->ClockMulFactor = 1;
+        if (cp->ClockDivFactor < 1)
+            cp->ClockDivFactor = 1;
+
+        /*
+         * XXX  The effect of clock dividers and multipliers on the monitor's
+         *      pixel clock needs to be verified.
+         */
+        if (scrp->progClock) {
+            mode->SynthClock = mode->Clock;
+        }
+        else {
+            i = xf86GetNearestClock(scrp, mode->Clock, allowDiv2,
+                                    cp->ClockDivFactor, cp->ClockMulFactor,
+                                    &needDiv2);
+            mode->SynthClock = (scrp->clock[i] * cp->ClockDivFactor) /
+                cp->ClockMulFactor;
+            if (needDiv2 & V_CLKDIV2)
+                mode->SynthClock /= 2;
+        }
+
+        status = (*scrp->ValidMode) (scrp->scrnIndex, mode, FALSE,
+                                     MODECHECK_INITIAL);
+        if (status != MODE_OK)
+            return status;
+
+        if (mode->HSync <= 0.0)
+            mode->HSync = (float) mode->SynthClock / (float) mode->CrtcHTotal;
+        if (mode->VRefresh <= 0.0)
+            mode->VRefresh = (mode->SynthClock * 1000.0)
+                / (mode->CrtcHTotal * mode->CrtcVTotal);
     }
-    
+
     mode->HSync = xf86ModeHSync(mode);
     mode->VRefresh = xf86ModeVRefresh(mode);
 
@@ -996,109 +1006,112 @@ xf86CheckModeForDriver(ScrnInfoPtr scrp, DisplayModePtr mode, int flags)
     ModeStatus status = MODE_NOMODE;
 
     /* Some sanity checking */
-    if (scrp == NULL ||	(!scrp->progClock && scrp->numClocks == 0)) {
-	ErrorF("xf86CheckModeForDriver: called with invalid scrnInfoRec\n");
-	return MODE_ERROR;
+    if (scrp == NULL || (!scrp->progClock && scrp->numClocks == 0)) {
+        ErrorF("xf86CheckModeForDriver: called with invalid scrnInfoRec\n");
+        return MODE_ERROR;
     }
     if (mode == NULL) {
-	ErrorF("xf86CheckModeForDriver: called with invalid modep\n");
-	return MODE_ERROR;
+        ErrorF("xf86CheckModeForDriver: called with invalid modep\n");
+        return MODE_ERROR;
     }
 
     /* Check the mode size */
     if (mode->HDisplay > scrp->virtualX)
-	return MODE_VIRTUAL_X;
+        return MODE_VIRTUAL_X;
 
     if (mode->VDisplay > scrp->virtualY)
-	return MODE_VIRTUAL_Y;
+        return MODE_VIRTUAL_Y;
 
     if (scrp->maxHValue > 0 && mode->HTotal > scrp->maxHValue)
-	return MODE_BAD_HVALUE;
+        return MODE_BAD_HVALUE;
 
     if (scrp->maxVValue > 0 && mode->VTotal > scrp->maxVValue)
-	return MODE_BAD_VVALUE;
+        return MODE_BAD_VVALUE;
 
     for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
-	/* DivFactor and MulFactor must be > 0 */
-	cp->ClockDivFactor = max(1, cp->ClockDivFactor);
-	cp->ClockMulFactor = max(1, cp->ClockMulFactor);
+        /* DivFactor and MulFactor must be > 0 */
+        cp->ClockDivFactor = max(1, cp->ClockDivFactor);
+        cp->ClockMulFactor = max(1, cp->ClockMulFactor);
     }
 
     if (scrp->progClock) {
-	/* Check clock is in range */
-	for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
-	    if (modeInClockRange(cp, mode))
-	        break;
-	}
-	if (cp == NULL) {
-	    return MODE_CLOCK_RANGE;
-	}
-	/*
-	 * If programmable clock the required mode has been found
-	 */
-    	DivFactor = cp->ClockDivFactor;
-	MulFactor = cp->ClockMulFactor;
-	ModePrivFlags = cp->PrivFlags;
-    } else {
-	 status = MODE_CLOCK_RANGE;
-	/* Check clock is in range */
-	for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
-	    if (modeInClockRange(cp, mode)) {
-		/*
-	 	 * Clock is in range, so if it is not a programmable clock,
-		 * find a matching clock.
-		 */
-    
-		i = xf86GetNearestClock(scrp, mode->Clock, 0,
-			   cp->ClockDivFactor, cp->ClockMulFactor, &k);
-		/*
-		 * If the clock is too far from the requested clock, this
-		 * mode is no good.
-		 */
-		if (k & V_CLKDIV2)
-		    gap = abs((mode->Clock * 2) -
-			      ((scrp->clock[i] * cp->ClockDivFactor) /
-			       cp->ClockMulFactor));
-		else
-		    gap = abs(mode->Clock -
-			      ((scrp->clock[i] * cp->ClockDivFactor) /
-			       cp->ClockMulFactor));
-		if (gap > minimumGap) {
-		    status = MODE_NOCLOCK;
-		    continue;
-		}
-		
-		DivFactor = cp->ClockDivFactor;
-		MulFactor = cp->ClockMulFactor;
-		ModePrivFlags = cp->PrivFlags;
-		extraFlags = k;
-		clockIndex = i;
-		break;
-	    }
-	}
-	if (cp == NULL)
-	    return status;
+        /* Check clock is in range */
+        for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
+            if (modeInClockRange(cp, mode))
+                break;
+        }
+        if (cp == NULL) {
+            return MODE_CLOCK_RANGE;
+        }
+        /*
+         * If programmable clock the required mode has been found
+         */
+        DivFactor = cp->ClockDivFactor;
+        MulFactor = cp->ClockMulFactor;
+        ModePrivFlags = cp->PrivFlags;
+    }
+    else {
+        status = MODE_CLOCK_RANGE;
+        /* Check clock is in range */
+        for (cp = scrp->clockRanges; cp != NULL; cp = cp->next) {
+            if (modeInClockRange(cp, mode)) {
+                /*
+                 * Clock is in range, so if it is not a programmable clock,
+                 * find a matching clock.
+                 */
+
+                i = xf86GetNearestClock(scrp, mode->Clock, 0,
+                                        cp->ClockDivFactor, cp->ClockMulFactor,
+                                        &k);
+                /*
+                 * If the clock is too far from the requested clock, this
+                 * mode is no good.
+                 */
+                if (k & V_CLKDIV2)
+                    gap = abs((mode->Clock * 2) -
+                              ((scrp->clock[i] * cp->ClockDivFactor) /
+                               cp->ClockMulFactor));
+                else
+                    gap = abs(mode->Clock -
+                              ((scrp->clock[i] * cp->ClockDivFactor) /
+                               cp->ClockMulFactor));
+                if (gap > minimumGap) {
+                    status = MODE_NOCLOCK;
+                    continue;
+                }
+
+                DivFactor = cp->ClockDivFactor;
+                MulFactor = cp->ClockMulFactor;
+                ModePrivFlags = cp->PrivFlags;
+                extraFlags = k;
+                clockIndex = i;
+                break;
+            }
+        }
+        if (cp == NULL)
+            return status;
     }
 
     /* Fill in the mode parameters */
     if (scrp->progClock) {
-	mode->ClockIndex	= -1;
-	mode->SynthClock	= (mode->Clock * MulFactor) / DivFactor;
-    } else {
-	mode->Clock		= (scrp->clock[clockIndex] * DivFactor) / MulFactor;
-	mode->ClockIndex	= clockIndex;
-	mode->SynthClock	= scrp->clock[clockIndex];
-	if (extraFlags & V_CLKDIV2) {
-	    mode->Clock /= 2;
-	    mode->SynthClock /= 2;
-	}
+        mode->ClockIndex = -1;
+        mode->SynthClock = (mode->Clock * MulFactor) / DivFactor;
     }
-    mode->PrivFlags		= ModePrivFlags;
+    else {
+        mode->Clock = (scrp->clock[clockIndex] * DivFactor) / MulFactor;
+        mode->ClockIndex = clockIndex;
+        mode->SynthClock = scrp->clock[clockIndex];
+        if (extraFlags & V_CLKDIV2) {
+            mode->Clock /= 2;
+            mode->SynthClock /= 2;
+        }
+    }
+    mode->PrivFlags = ModePrivFlags;
 
     return MODE_OK;
 }
 
-static int 
+static int
 inferVirtualSize(ScrnInfoPtr scrp, DisplayModePtr modes, int *vx, int *vy)
 {
     float aspect = 0.0;
@@ -1107,24 +1120,25 @@ inferVirtualSize(ScrnInfoPtr scrp, DisplayModePtr modes, int *vx, int *vy)
     int x = 0, y = 0;
     DisplayModePtr mode;
 
-    if (!mon) return 0;
+    if (!mon)
+        return 0;
     DDC = mon->DDC;
 
     if (DDC && DDC->ver.revision >= 4) {
-	/* For 1.4, we might actually get native pixel format.  How novel. */
-	if (PREFERRED_TIMING_MODE(DDC->features.msc)) {
-		for (mode = modes; mode; mode = mode->next) {
-		    if (mode->type & (M_T_DRIVER | M_T_PREFERRED)) {
-			x = mode->HDisplay;
-			y = mode->VDisplay;
-			goto found;
-		    }
-		}
-	}
-	/*
-	 * Even if we don't, we might get aspect ratio from extra CVT info
-	 * or from the monitor size fields.  TODO.
-	 */
+        /* For 1.4, we might actually get native pixel format.  How novel. */
+        if (PREFERRED_TIMING_MODE(DDC->features.msc)) {
+            for (mode = modes; mode; mode = mode->next) {
+                if (mode->type & (M_T_DRIVER | M_T_PREFERRED)) {
+                    x = mode->HDisplay;
+                    y = mode->VDisplay;
+                    goto found;
+                }
+            }
+        }
+        /*
+         * Even if we don't, we might get aspect ratio from extra CVT info
+         * or from the monitor size fields.  TODO.
+         */
     }
 
     /*
@@ -1132,41 +1146,42 @@ inferVirtualSize(ScrnInfoPtr scrp, DisplayModePtr modes, int *vx, int *vy)
      * before EDID 1.4, but right now we'll get that wrong. TODO.
      */
     if (!aspect) {
-	if (!mon->widthmm || !mon->heightmm)
-	    aspect = 4.0/3.0;
-	else
-	    aspect = (float)mon->widthmm / (float)mon->heightmm;
+        if (!mon->widthmm || !mon->heightmm)
+            aspect = 4.0 / 3.0;
+        else
+            aspect = (float) mon->widthmm / (float) mon->heightmm;
     }
 
     /* find the largest M_T_DRIVER mode with that aspect ratio */
     for (mode = modes; mode; mode = mode->next) {
-	float mode_aspect, metaspect;
-	if (!(mode->type & (M_T_DRIVER|M_T_USERDEF)))
-	    continue;
-	mode_aspect = (float)mode->HDisplay / (float)mode->VDisplay;
-	metaspect = aspect / mode_aspect;
-	/* 5% slop or so, since we only get size in centimeters */
-	if (fabs(1.0 - metaspect) < 0.05) {
-	    if ((mode->HDisplay > x) && (mode->VDisplay > y)) {
-		x = mode->HDisplay;
-		y = mode->VDisplay;
-	    }
-	}
+        float mode_aspect, metaspect;
+
+        if (!(mode->type & (M_T_DRIVER | M_T_USERDEF)))
+            continue;
+        mode_aspect = (float) mode->HDisplay / (float) mode->VDisplay;
+        metaspect = aspect / mode_aspect;
+        /* 5% slop or so, since we only get size in centimeters */
+        if (fabs(1.0 - metaspect) < 0.05) {
+            if ((mode->HDisplay > x) && (mode->VDisplay > y)) {
+                x = mode->HDisplay;
+                y = mode->VDisplay;
+            }
+        }
     }
 
     if (!x || !y) {
-	xf86DrvMsg(scrp->scrnIndex, X_WARNING,
-		   "Unable to estimate virtual size\n");
-	return 0;
+        xf86DrvMsg(scrp->scrnIndex, X_WARNING,
+                   "Unable to estimate virtual size\n");
+        return 0;
     }
 
-found:
+ found:
     *vx = x;
     *vy = y;
 
     xf86DrvMsg(scrp->scrnIndex, X_INFO,
-	       "Estimated virtual size for aspect ratio %.4f is %dx%d\n",
-	       aspect, *vx, *vy);
+               "Estimated virtual size for aspect ratio %.4f is %dx%d\n",
+               aspect, *vx, *vy);
 
     return 1;
 }
@@ -1177,8 +1192,7 @@ LCM(unsigned int x, unsigned int y)
 {
     unsigned int m = x, n = y, o;
 
-    while ((o = m % n))
-    {
+    while ((o = m % n)) {
         m = n;
         n = o;
     }
@@ -1193,14 +1207,12 @@ LCM(unsigned int x, unsigned int y)
  * cannot exist.
  */
 static int
-scanLineWidth(
-    unsigned int     xsize,         /* pixels */
-    unsigned int     ysize,         /* pixels */
-    unsigned int     width,         /* pixels */
-    unsigned long    BankSize,      /* char's */
-    PixmapFormatRec *pBankFormat,
-    unsigned int     nWidthUnit     /* bits */
-)
+scanLineWidth(unsigned int xsize,       /* pixels */
+              unsigned int ysize,       /* pixels */
+              unsigned int width,       /* pixels */
+              unsigned long BankSize,   /* char's */
+              PixmapFormatRec * pBankFormat, unsigned int nWidthUnit    /* bits */
+    )
 {
     unsigned long nBitsPerBank, nBitsPerScanline, nBitsPerScanlinePadUnit;
     unsigned long minBitsPerScanline, maxBitsPerScanline;
@@ -1223,7 +1235,7 @@ scanLineWidth(
     width = nBitsPerScanline / pBankFormat->bitsPerPixel;
 
     if (!xsize || !(nBitsPerBank % pBankFormat->bitsPerPixel))
-        return (int)width;
+        return (int) width;
 
     /*
      * Scanlines will be server-pad aligned at this point.  They will also be
@@ -1244,40 +1256,36 @@ scanLineWidth(
         return -1;
 
     if (ysize == 1)
-        return (int)width;
+        return (int) width;
 
     maxBitsPerScanline =
-        (((unsigned long)(-1) >> 1) - minBitsPerScanline) / (ysize - 1);
-    while (nBitsPerScanline <= maxBitsPerScanline)
-    {
+        (((unsigned long) (-1) >> 1) - minBitsPerScanline) / (ysize - 1);
+    while (nBitsPerScanline <= maxBitsPerScanline) {
         unsigned long BankBase, BankUnit;
 
         BankUnit = ((nBitsPerBank + nBitsPerScanline - 1) / nBitsPerBank) *
             nBitsPerBank;
         if (!(BankUnit % nBitsPerScanline))
-            return (int)width;
+            return (int) width;
 
-        for (BankBase = BankUnit;  ;  BankBase += nBitsPerBank)
-        {
+        for (BankBase = BankUnit;; BankBase += nBitsPerBank) {
             unsigned long x, y;
 
             y = BankBase / nBitsPerScanline;
             if (y >= ysize)
-                return (int)width;
+                return (int) width;
 
             x = BankBase % nBitsPerScanline;
             if (!(x % pBankFormat->bitsPerPixel))
                 continue;
 
-            if (x < minBitsPerScanline)
-            {
+            if (x < minBitsPerScanline) {
                 /*
                  * Skip ahead certain widths by dividing the excess scanline
                  * amongst the y's.
                  */
                 y *= nBitsPerScanlinePadUnit;
-                nBitsPerScanline +=
-                    ((x + y - 1) / y) * nBitsPerScanlinePadUnit;
+                nBitsPerScanline += ((x + y - 1) / y) * nBitsPerScanlinePadUnit;
                 width = nBitsPerScanline / pBankFormat->bitsPerPixel;
                 break;
             }
@@ -1286,10 +1294,10 @@ scanLineWidth(
                 continue;
 
             if (!(nBitsPerScanline % x))
-                return (int)width;
+                return (int) width;
 
             BankBase = ((nBitsPerScanline - minBitsPerScanline) /
-                (nBitsPerScanline - x)) * BankUnit;
+                        (nBitsPerScanline - x)) * BankUnit;
         }
     }
 
@@ -1346,17 +1354,17 @@ scanLineWidth(
 
 int
 xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
-		  char **modeNames, ClockRangePtr clockRanges,
-		  int *linePitches, int minPitch, int maxPitch, int pitchInc,
-		  int minHeight, int maxHeight, int virtualX, int virtualY,
-		  int apertureSize, LookupModeFlags strategy)
+                  char **modeNames, ClockRangePtr clockRanges,
+                  int *linePitches, int minPitch, int maxPitch, int pitchInc,
+                  int minHeight, int maxHeight, int virtualX, int virtualY,
+                  int apertureSize, LookupModeFlags strategy)
 {
     DisplayModePtr p, q, r, new, last, *endp;
     int i, numModes = 0;
     ModeStatus status;
     int linePitch = -1, virtX = 0, virtY = 0;
     int newLinePitch, newVirtX, newVirtY;
-    int modeSize;					/* in pixels */
+    int modeSize;               /* in pixels */
     Bool validateAllDefaultModes = FALSE;
     Bool userModes = FALSE;
     int saveType;
@@ -1368,30 +1376,29 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
     range vrefresh[MAX_VREFRESH];
     Bool inferred_virtual = FALSE;
 
-    DebugF("xf86ValidateModes(%p, %p, %p, %p,\n\t\t  %p, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x)\n",
-	   scrp, availModes, modeNames, clockRanges,
-	   linePitches, minPitch, maxPitch, pitchInc,
-	   minHeight, maxHeight, virtualX, virtualY,
-	   apertureSize, strategy
-	   );
+    DebugF
+        ("xf86ValidateModes(%p, %p, %p, %p,\n\t\t  %p, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x)\n",
+         scrp, availModes, modeNames, clockRanges, linePitches, minPitch,
+         maxPitch, pitchInc, minHeight, maxHeight, virtualX, virtualY,
+         apertureSize, strategy);
 
     /* Some sanity checking */
     if (scrp == NULL || scrp->name == NULL || !scrp->monitor ||
-	(!scrp->progClock && scrp->numClocks == 0)) {
-	ErrorF("xf86ValidateModes: called with invalid scrnInfoRec\n");
-	return -1;
+        (!scrp->progClock && scrp->numClocks == 0)) {
+        ErrorF("xf86ValidateModes: called with invalid scrnInfoRec\n");
+        return -1;
     }
     if (linePitches != NULL && linePitches[0] <= 0) {
-	ErrorF("xf86ValidateModes: called with invalid linePitches\n");
-	return -1;
+        ErrorF("xf86ValidateModes: called with invalid linePitches\n");
+        return -1;
     }
     if (pitchInc <= 0) {
-	ErrorF("xf86ValidateModes: called with invalid pitchInc\n");
-	return -1;
+        ErrorF("xf86ValidateModes: called with invalid pitchInc\n");
+        return -1;
     }
     if ((virtualX > 0) != (virtualY > 0)) {
-	ErrorF("xf86ValidateModes: called with invalid virtual resolution\n");
-	return -1;
+        ErrorF("xf86ValidateModes: called with invalid virtual resolution\n");
+        return -1;
     }
 
     /*
@@ -1399,83 +1406,87 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      * in the monitor section.
      */
     if (strategy & LOOKUP_OPTIONAL_TOLERANCES) {
-	strategy &= ~LOOKUP_OPTIONAL_TOLERANCES;
-    } else {
-	const char *type = "";
+        strategy &= ~LOOKUP_OPTIONAL_TOLERANCES;
+    }
+    else {
+        const char *type = "";
         Bool specified = FALSE;
 
-	if (scrp->monitor->nHsync <= 0) {
-	    if (numTimings > 0) {
-		scrp->monitor->nHsync = numTimings;
-		for (i = 0; i < numTimings; i++) {
-		    scrp->monitor->hsync[i].lo = hsync[i].lo;
-		    scrp->monitor->hsync[i].hi = hsync[i].hi;
-		}
-	    } else {
-		scrp->monitor->hsync[0].lo = 31.5;
-		scrp->monitor->hsync[0].hi = 48.0;
-		scrp->monitor->nHsync = 1;
-	    }
-	    type = "default ";
-	} else {
+        if (scrp->monitor->nHsync <= 0) {
+            if (numTimings > 0) {
+                scrp->monitor->nHsync = numTimings;
+                for (i = 0; i < numTimings; i++) {
+                    scrp->monitor->hsync[i].lo = hsync[i].lo;
+                    scrp->monitor->hsync[i].hi = hsync[i].hi;
+                }
+            }
+            else {
+                scrp->monitor->hsync[0].lo = 31.5;
+                scrp->monitor->hsync[0].hi = 48.0;
+                scrp->monitor->nHsync = 1;
+            }
+            type = "default ";
+        }
+        else {
             specified = TRUE;
         }
-	for (i = 0; i < scrp->monitor->nHsync; i++) {
-	    if (scrp->monitor->hsync[i].lo == scrp->monitor->hsync[i].hi)
-	      xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			 "%s: Using %shsync value of %.2f kHz\n",
-			 scrp->monitor->id, type,
-			 scrp->monitor->hsync[i].lo);
-	    else
-	      xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			 "%s: Using %shsync range of %.2f-%.2f kHz\n",
-			 scrp->monitor->id, type,
-			 scrp->monitor->hsync[i].lo,
-			 scrp->monitor->hsync[i].hi);
-	}
-
-	type = "";
-	if (scrp->monitor->nVrefresh <= 0) {
-	    if (numTimings > 0) {
-		scrp->monitor->nVrefresh = numTimings;
-		for (i = 0; i < numTimings; i++) {
-		    scrp->monitor->vrefresh[i].lo = vrefresh[i].lo;
-		    scrp->monitor->vrefresh[i].hi = vrefresh[i].hi;
-		}
-	    } else {
-		scrp->monitor->vrefresh[0].lo = 50;
-		scrp->monitor->vrefresh[0].hi = 70;
-		scrp->monitor->nVrefresh = 1;
-	    }
-	    type = "default ";
-	} else {
+        for (i = 0; i < scrp->monitor->nHsync; i++) {
+            if (scrp->monitor->hsync[i].lo == scrp->monitor->hsync[i].hi)
+                xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                           "%s: Using %shsync value of %.2f kHz\n",
+                           scrp->monitor->id, type, scrp->monitor->hsync[i].lo);
+            else
+                xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                           "%s: Using %shsync range of %.2f-%.2f kHz\n",
+                           scrp->monitor->id, type,
+                           scrp->monitor->hsync[i].lo,
+                           scrp->monitor->hsync[i].hi);
+        }
+
+        type = "";
+        if (scrp->monitor->nVrefresh <= 0) {
+            if (numTimings > 0) {
+                scrp->monitor->nVrefresh = numTimings;
+                for (i = 0; i < numTimings; i++) {
+                    scrp->monitor->vrefresh[i].lo = vrefresh[i].lo;
+                    scrp->monitor->vrefresh[i].hi = vrefresh[i].hi;
+                }
+            }
+            else {
+                scrp->monitor->vrefresh[0].lo = 50;
+                scrp->monitor->vrefresh[0].hi = 70;
+                scrp->monitor->nVrefresh = 1;
+            }
+            type = "default ";
+        }
+        else {
             specified = TRUE;
         }
-	for (i = 0; i < scrp->monitor->nVrefresh; i++) {
-	    if (scrp->monitor->vrefresh[i].lo == scrp->monitor->vrefresh[i].hi)
-	      xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			 "%s: Using %svrefresh value of %.2f Hz\n",
-			 scrp->monitor->id, type,
-			 scrp->monitor->vrefresh[i].lo);
-	    else
-	      xf86DrvMsg(scrp->scrnIndex, X_INFO,
-			 "%s: Using %svrefresh range of %.2f-%.2f Hz\n",
-			 scrp->monitor->id, type,
-			 scrp->monitor->vrefresh[i].lo,
-			 scrp->monitor->vrefresh[i].hi);
-	}
+        for (i = 0; i < scrp->monitor->nVrefresh; i++) {
+            if (scrp->monitor->vrefresh[i].lo == scrp->monitor->vrefresh[i].hi)
+                xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                           "%s: Using %svrefresh value of %.2f Hz\n",
+                           scrp->monitor->id, type,
+                           scrp->monitor->vrefresh[i].lo);
+            else
+                xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                           "%s: Using %svrefresh range of %.2f-%.2f Hz\n",
+                           scrp->monitor->id, type,
+                           scrp->monitor->vrefresh[i].lo,
+                           scrp->monitor->vrefresh[i].hi);
+        }
 
         type = "";
-	if (!scrp->monitor->maxPixClock && !specified) {
+        if (!scrp->monitor->maxPixClock && !specified) {
             type = "default ";
             scrp->monitor->maxPixClock = 65000.0;
         }
-	if (scrp->monitor->maxPixClock) {
-	    xf86DrvMsg(scrp->scrnIndex, X_INFO,
-		       "%s: Using %smaximum pixel clock of %.2f MHz\n",
-		       scrp->monitor->id, type,
-		       (float)scrp->monitor->maxPixClock / 1000.0);
-	}
+        if (scrp->monitor->maxPixClock) {
+            xf86DrvMsg(scrp->scrnIndex, X_INFO,
+                       "%s: Using %smaximum pixel clock of %.2f MHz\n",
+                       scrp->monitor->id, type,
+                       (float) scrp->monitor->maxPixClock / 1000.0);
+        }
     }
 
     /*
@@ -1483,24 +1494,24 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      */
     storeClockRanges = scrp->clockRanges;
     while (storeClockRanges != NULL) {
-	storeClockRanges = storeClockRanges->next;
+        storeClockRanges = storeClockRanges->next;
     }
     for (cp = clockRanges; cp != NULL; cp = cp->next,
-	   	storeClockRanges = storeClockRanges->next) {
-	storeClockRanges = xnfalloc(sizeof(ClockRange));
-	if (scrp->clockRanges == NULL)
-	    scrp->clockRanges = storeClockRanges;
-	memcpy(storeClockRanges, cp, sizeof(ClockRange));
+         storeClockRanges = storeClockRanges->next) {
+        storeClockRanges = xnfalloc(sizeof(ClockRange));
+        if (scrp->clockRanges == NULL)
+            scrp->clockRanges = storeClockRanges;
+        memcpy(storeClockRanges, cp, sizeof(ClockRange));
     }
 
     /* Determine which pixmap format to pass to scanLineWidth() */
     if (scrp->depth > 4)
-	BankFormat = &scrp->fbFormat;
+        BankFormat = &scrp->fbFormat;
     else
-	BankFormat = xf86GetPixFormat(scrp, 1);	/* >not< scrp->depth! */
+        BankFormat = xf86GetPixFormat(scrp, 1); /* >not< scrp->depth! */
 
     if (scrp->xInc <= 0)
-        scrp->xInc = 8;		/* Suitable for VGA and others */
+        scrp->xInc = 8;         /* Suitable for VGA and others */
 
 #define _VIRTUALX(x) ((((x) + scrp->xInc - 1) / scrp->xInc) * scrp->xInc)
 
@@ -1510,13 +1521,13 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      * maxPitch values passed are ignored.
      */
     if (linePitches) {
-	minPitch = maxPitch = linePitches[0];
-	for (i = 1; linePitches[i] > 0; i++) {
-	    if (linePitches[i] > maxPitch)
-		maxPitch = linePitches[i];
-	    if (linePitches[i] < minPitch)
-		minPitch = linePitches[i];
-	}
+        minPitch = maxPitch = linePitches[0];
+        for (i = 1; linePitches[i] > 0; i++) {
+            if (linePitches[i] > maxPitch)
+                maxPitch = linePitches[i];
+            if (linePitches[i] < minPitch)
+                minPitch = linePitches[i];
+        }
     }
 
     /* Initial check of virtual size against other constraints */
@@ -1525,60 +1536,62 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      * Initialise virtX and virtY if the values are fixed.
      */
     if (virtualY > 0) {
-	if (maxHeight > 0 && virtualY > maxHeight) {
-	    xf86DrvMsg(scrp->scrnIndex, X_ERROR,
-		       "Virtual height (%d) is too large for the hardware "
-		       "(max %d)\n", virtualY, maxHeight);
-	    return -1;
-	}
-
-	if (minHeight > 0 && virtualY < minHeight) {
-	    xf86DrvMsg(scrp->scrnIndex, X_ERROR,
-		       "Virtual height (%d) is too small for the hardware "
-		       "(min %d)\n", virtualY, minHeight);
-	    return -1;
-	}
-
-	virtualX = _VIRTUALX(virtualX);
-	if (linePitches != NULL) {
-	    for (i = 0; linePitches[i] != 0; i++) {
-		if ((linePitches[i] >= virtualX) &&
-		    (linePitches[i] ==
-		     scanLineWidth(virtualX, virtualY, linePitches[i],
-				   apertureSize, BankFormat, pitchInc))) {
-		    linePitch = linePitches[i];
-		    break;
-		}
-	    }
-	} else {
-	    linePitch = scanLineWidth(virtualX, virtualY, minPitch,
-				      apertureSize, BankFormat, pitchInc);
-	}
-
-	if ((linePitch < minPitch) || (linePitch > maxPitch)) {
-	    xf86DrvMsg(scrp->scrnIndex, X_ERROR,
-		       "Virtual width (%d) is too large for the hardware "
-		       "(max %d)\n", virtualX, maxPitch);
-	    return -1;
-	}
-
-	if (!xf86CheckModeSize(scrp, linePitch, virtualX, virtualY)) {
-	    xf86DrvMsg(scrp->scrnIndex, X_ERROR,
-		      "Virtual size (%dx%d) (pitch %d) exceeds video memory\n",
-		      virtualX, virtualY, linePitch);
-	    return -1;
-	}
-
-	virtX = virtualX;
-	virtY = virtualY;
-	scrp->virtualFrom = X_CONFIG;
-    } else if (!modeNames || !*modeNames) {
-	/* No virtual size given in the config, try to infer */
-	/* XXX this doesn't take m{in,ax}Pitch into account; oh well */
-	inferred_virtual = inferVirtualSize(scrp, availModes, &virtX, &virtY);
-	if (inferred_virtual)
-	    linePitch = scanLineWidth(virtX, virtY, minPitch, apertureSize,
-				      BankFormat, pitchInc);
+        if (maxHeight > 0 && virtualY > maxHeight) {
+            xf86DrvMsg(scrp->scrnIndex, X_ERROR,
+                       "Virtual height (%d) is too large for the hardware "
+                       "(max %d)\n", virtualY, maxHeight);
+            return -1;
+        }
+
+        if (minHeight > 0 && virtualY < minHeight) {
+            xf86DrvMsg(scrp->scrnIndex, X_ERROR,
+                       "Virtual height (%d) is too small for the hardware "
+                       "(min %d)\n", virtualY, minHeight);
+            return -1;
+        }
+
+        virtualX = _VIRTUALX(virtualX);
+        if (linePitches != NULL) {
+            for (i = 0; linePitches[i] != 0; i++) {
+                if ((linePitches[i] >= virtualX) &&
+                    (linePitches[i] ==
+                     scanLineWidth(virtualX, virtualY, linePitches[i],
+                                   apertureSize, BankFormat, pitchInc))) {
+                    linePitch = linePitches[i];
+                    break;
+                }
+            }
+        }
+        else {
+            linePitch = scanLineWidth(virtualX, virtualY, minPitch,
+                                      apertureSize, BankFormat, pitchInc);
+        }
+
+        if ((linePitch < minPitch) || (linePitch > maxPitch)) {
+            xf86DrvMsg(scrp->scrnIndex, X_ERROR,
+                       "Virtual width (%d) is too large for the hardware "
+                       "(max %d)\n", virtualX, maxPitch);
+            return -1;
+        }
+
+        if (!xf86CheckModeSize(scrp, linePitch, virtualX, virtualY)) {
+            xf86DrvMsg(scrp->scrnIndex, X_ERROR,
+                       "Virtual size (%dx%d) (pitch %d) exceeds video memory\n",
+                       virtualX, virtualY, linePitch);
+            return -1;
+        }
+
+        virtX = virtualX;
+        virtY = virtualY;
+        scrp->virtualFrom = X_CONFIG;
+    }
+    else if (!modeNames || !*modeNames) {
+        /* No virtual size given in the config, try to infer */
+        /* XXX this doesn't take m{in,ax}Pitch into account; oh well */
+        inferred_virtual = inferVirtualSize(scrp, availModes, &virtX, &virtY);
+        if (inferred_virtual)
+            linePitch = scanLineWidth(virtX, virtY, minPitch, apertureSize,
+                                      BankFormat, pitchInc);
     }
 
     /* Print clock ranges and scaled clocks */
@@ -1591,253 +1604,256 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      * member of the scrp->modes list for which a match was considered.
      */
     if (scrp->modePool == NULL) {
-	q = NULL;
-	for (p = availModes; p != NULL; p = p->next) {
-	    status = xf86InitialCheckModeForDriver(scrp, p, clockRanges,
-						   strategy, maxPitch,
-						   virtX, virtY);
-
-	    if (status == MODE_OK) {
-		status = xf86CheckModeForMonitor(p, scrp->monitor);
-	    }
-	    
-	    if (status == MODE_OK) {
-		new = xnfalloc(sizeof(DisplayModeRec));
-		*new = *p;
-		new->next = NULL;
-		if (!q) {
-		    scrp->modePool = new;
-		} else {
-		    q->next = new;
-		}
-		new->prev = NULL;
-		q = new;
-		q->name = xnfstrdup(p->name);
-	        q->status = MODE_OK;
-	    } else {
-		printModeRejectMessage(scrp->scrnIndex, p, status);
-	    }
-	}
-
-	if (scrp->modePool == NULL) {
-	    xf86DrvMsg(scrp->scrnIndex, X_WARNING, "Mode pool is empty\n");
-	    return 0;
-	}
-    } else {
-	for (p = scrp->modePool; p != NULL; p = p->next) {
-	    p->prev = NULL;
-	    p->status = MODE_OK;
-	}
+        q = NULL;
+        for (p = availModes; p != NULL; p = p->next) {
+            status = xf86InitialCheckModeForDriver(scrp, p, clockRanges,
+                                                   strategy, maxPitch,
+                                                   virtX, virtY);
+
+            if (status == MODE_OK) {
+                status = xf86CheckModeForMonitor(p, scrp->monitor);
+            }
+
+            if (status == MODE_OK) {
+                new = xnfalloc(sizeof(DisplayModeRec));
+                *new = *p;
+                new->next = NULL;
+                if (!q) {
+                    scrp->modePool = new;
+                }
+                else {
+                    q->next = new;
+                }
+                new->prev = NULL;
+                q = new;
+                q->name = xnfstrdup(p->name);
+                q->status = MODE_OK;
+            }
+            else {
+                printModeRejectMessage(scrp->scrnIndex, p, status);
+            }
+        }
+
+        if (scrp->modePool == NULL) {
+            xf86DrvMsg(scrp->scrnIndex, X_WARNING, "Mode pool is empty\n");
+            return 0;
+        }
+    }
+    else {
+        for (p = scrp->modePool; p != NULL; p = p->next) {
+            p->prev = NULL;
+            p->status = MODE_OK;
+        }
     }
 
     /*
      * Allocate one entry in scrp->modes for each named mode.
      */
     while (scrp->modes)
-	xf86DeleteMode(&scrp->modes, scrp->modes);
+        xf86DeleteMode(&scrp->modes, scrp->modes);
     endp = &scrp->modes;
     last = NULL;
     if (modeNames != NULL) {
-	for (i = 0; modeNames[i] != NULL; i++) {
-	    userModes = TRUE;
-	    new = xnfcalloc(1, sizeof(DisplayModeRec));
-	    new->prev = last;
-	    new->type = M_T_USERDEF;
-	    new->name = xnfstrdup(modeNames[i]);
-	    if (new->prev)
-		new->prev->next = new;
-	    *endp = last = new;
-	    endp = &new->next;
-	}
+        for (i = 0; modeNames[i] != NULL; i++) {
+            userModes = TRUE;
+            new = xnfcalloc(1, sizeof(DisplayModeRec));
+            new->prev = last;
+            new->type = M_T_USERDEF;
+            new->name = xnfstrdup(modeNames[i]);
+            if (new->prev)
+                new->prev->next = new;
+            *endp = last = new;
+            endp = &new->next;
+        }
     }
 
     /* Lookup each mode */
 #ifdef RANDR
-    if (!xf86Info.disableRandR	
+    if (!xf86Info.disableRandR
 #ifdef PANORAMIX
-	&& noPanoramiXExtension
+        && noPanoramiXExtension
 #endif
-	)
-	validateAllDefaultModes = TRUE;
+        )
+        validateAllDefaultModes = TRUE;
 #endif
 
-    for (p = scrp->modes; ; p = p->next) {
-	Bool repeat;
-
-	/*
-	 * If the supplied mode names don't produce a valid mode, scan through
-	 * unconsidered modePool members until one survives validation.  This
-	 * is done in decreasing order by mode pixel area.
-	 */
-
-	if (p == NULL) {
-	    if ((numModes > 0) && !validateAllDefaultModes)
-		break;
-
-	    validateAllDefaultModes = TRUE;
-	    r = NULL;
-	    modeSize = 0;
-	    for (q = scrp->modePool;  q != NULL;  q = q->next) {
-		if ((q->prev == NULL) && (q->status == MODE_OK)) {
-		    /*
-		     * Deal with the case where this mode wasn't considered
-		     * because of a builtin mode of the same name.
-		     */
-		    for (p = scrp->modes; p != NULL; p = p->next) {
-			if ((p->status != MODE_OK) &&
-			    !strcmp(p->name, q->name))
-			    break;
-		    }
-
-		    if (p != NULL)
-			q->prev = p;
-		    else {
-			/*
-			 * A quick check to not allow default modes with
-			 * horizontal timing parameters that CRTs may have
-			 * problems with.
-			 */
-			if (!scrp->monitor->reducedblanking &&
-			    (q->type & M_T_DEFAULT) &&
-			    ((double)q->HTotal / (double)q->HDisplay) < 1.15)
-			    continue;
-
-			if (modeSize < (q->HDisplay * q->VDisplay)) {
-			    r = q;
-			    modeSize = q->HDisplay * q->VDisplay;
-			}
-		    }
-		}
-	    }
-
-	    if (r == NULL)
-		break;
-
-	    p = xnfcalloc(1, sizeof(DisplayModeRec));
-	    p->prev = last;
-	    p->name = xnfstrdup(r->name);
-	    if (!userModes)
-		p->type = M_T_USERDEF;
-	    if (p->prev)
-		p->prev->next = p;
-	    *endp = last = p;
-	    endp = &p->next;
-	}
-
-	repeat = FALSE;
-    lookupNext:
-	if (repeat && ((status = p->status) != MODE_OK))
-	    printModeRejectMessage(scrp->scrnIndex, p, status);
-	saveType = p->type;
-	status = xf86LookupMode(scrp, p, clockRanges, strategy);
-	if (repeat && status == MODE_NOMODE)
-	    continue;
-	if (status != MODE_OK)
-	    printModeRejectMessage(scrp->scrnIndex, p, status);
-	if (status == MODE_ERROR) {
-	    ErrorF("xf86ValidateModes: "
-		   "unexpected result from xf86LookupMode()\n");
-	    return -1;
-	}
-	if (status != MODE_OK) {
-	    if (p->status == MODE_OK)
-		p->status = status;
-	    continue;
-	}
-	p->type |= saveType;
-	repeat = TRUE;
-
-	newLinePitch = linePitch;
-	newVirtX = virtX;
-	newVirtY = virtY;
-
-	/*
-	 * Don't let non-user defined modes increase the virtual size
-	 */
-	if (!(p->type & M_T_USERDEF) && (numModes > 0)) {
-	    if (p->HDisplay > virtX) {
-		p->status = MODE_VIRTUAL_X;
-		goto lookupNext;
-	    }
-	    if (p->VDisplay > virtY) {
-		p->status = MODE_VIRTUAL_Y;
-		goto lookupNext;
-	    }
-	}
-	/*
-	 * Adjust virtual width and height if the mode is too large for the
-	 * current values and if they are not fixed.
-	 */
-	if (virtualX <= 0 && p->HDisplay > newVirtX)
-	    newVirtX = _VIRTUALX(p->HDisplay);
-	if (virtualY <= 0 && p->VDisplay > newVirtY) {
-	    if (maxHeight > 0 && p->VDisplay > maxHeight) {
-		p->status = MODE_VIRTUAL_Y;	/* ? */
-		goto lookupNext;
-	    }
-	    newVirtY = p->VDisplay;
-	}
-
-	/*
-	 * If virtual resolution is to be increased, revalidate it.
-	 */
-	if ((virtX != newVirtX) || (virtY != newVirtY)) {
-	    if (linePitches != NULL) {
-		newLinePitch = -1;
-		for (i = 0; linePitches[i] != 0; i++) {
-		    if ((linePitches[i] >= newVirtX) &&
-			(linePitches[i] >= linePitch) &&
-			(linePitches[i] ==
-			 scanLineWidth(newVirtX, newVirtY, linePitches[i],
-				       apertureSize, BankFormat, pitchInc))) {
-			newLinePitch = linePitches[i];
-			break;
-		    }
-		}
-	    } else {
-		if (linePitch < minPitch)
-		    linePitch = minPitch;
-		newLinePitch = scanLineWidth(newVirtX, newVirtY, linePitch,
-					     apertureSize, BankFormat,
-					     pitchInc);
-	    }
-	    if ((newLinePitch < minPitch) || (newLinePitch > maxPitch)) {
-		p->status = MODE_BAD_WIDTH;
-		goto lookupNext;
-	    }
-
-	    /*
-	     * Check that the pixel area required by the new virtual height
-	     * and line pitch isn't too large.
-	     */
-	    if (!xf86CheckModeSize(scrp, newLinePitch, newVirtX, newVirtY)) {
-		p->status = MODE_MEM_VIRT;
-		goto lookupNext;
-	    }
-	}
-
-	if (scrp->ValidMode) {
-	    /*
-	     * Give the driver a final say, passing it the proposed virtual
-	     * geometry.
-	     */
-	    scrp->virtualX = newVirtX;
-	    scrp->virtualY = newVirtY;
-	    scrp->displayWidth = newLinePitch;
-	    p->status = (scrp->ValidMode)(scrp->scrnIndex, p, FALSE,
-					  MODECHECK_FINAL);
-
-	    if (p->status != MODE_OK) {
-	        goto lookupNext;
-	    }
-	}
-
-	/* Mode has passed all the tests */
-	virtX = newVirtX;
-	virtY = newVirtY;
-	linePitch = newLinePitch;
-	p->status = MODE_OK;
-	numModes++;
+    for (p = scrp->modes;; p = p->next) {
+        Bool repeat;
+
+        /*
+         * If the supplied mode names don't produce a valid mode, scan through
+         * unconsidered modePool members until one survives validation.  This
+         * is done in decreasing order by mode pixel area.
+         */
+
+        if (p == NULL) {
+            if ((numModes > 0) && !validateAllDefaultModes)
+                break;
+
+            validateAllDefaultModes = TRUE;
+            r = NULL;
+            modeSize = 0;
+            for (q = scrp->modePool; q != NULL; q = q->next) {
+                if ((q->prev == NULL) && (q->status == MODE_OK)) {
+                    /*
+                     * Deal with the case where this mode wasn't considered
+                     * because of a builtin mode of the same name.
+                     */
+                    for (p = scrp->modes; p != NULL; p = p->next) {
+                        if ((p->status != MODE_OK) && !strcmp(p->name, q->name))
+                            break;
+                    }
+
+                    if (p != NULL)
+                        q->prev = p;
+                    else {
+                        /*
+                         * A quick check to not allow default modes with
+                         * horizontal timing parameters that CRTs may have
+                         * problems with.
+                         */
+                        if (!scrp->monitor->reducedblanking &&
+                            (q->type & M_T_DEFAULT) &&
+                            ((double) q->HTotal / (double) q->HDisplay) < 1.15)
+                            continue;
+
+                        if (modeSize < (q->HDisplay * q->VDisplay)) {
+                            r = q;
+                            modeSize = q->HDisplay * q->VDisplay;
+                        }
+                    }
+                }
+            }
+
+            if (r == NULL)
+                break;
+
+            p = xnfcalloc(1, sizeof(DisplayModeRec));
+            p->prev = last;
+            p->name = xnfstrdup(r->name);
+            if (!userModes)
+                p->type = M_T_USERDEF;
+            if (p->prev)
+                p->prev->next = p;
+            *endp = last = p;
+            endp = &p->next;
+        }
+
+        repeat = FALSE;
+ lookupNext:
+        if (repeat && ((status = p->status) != MODE_OK))
+            printModeRejectMessage(scrp->scrnIndex, p, status);
+        saveType = p->type;
+        status = xf86LookupMode(scrp, p, clockRanges, strategy);
+        if (repeat && status == MODE_NOMODE)
+            continue;
+        if (status != MODE_OK)
+            printModeRejectMessage(scrp->scrnIndex, p, status);
+        if (status == MODE_ERROR) {
+            ErrorF("xf86ValidateModes: "
+                   "unexpected result from xf86LookupMode()\n");
+            return -1;
+        }
+        if (status != MODE_OK) {
+            if (p->status == MODE_OK)
+                p->status = status;
+            continue;
+        }
+        p->type |= saveType;
+        repeat = TRUE;
+
+        newLinePitch = linePitch;
+        newVirtX = virtX;
+        newVirtY = virtY;
+
+        /*
+         * Don't let non-user defined modes increase the virtual size
+         */
+        if (!(p->type & M_T_USERDEF) && (numModes > 0)) {
+            if (p->HDisplay > virtX) {
+                p->status = MODE_VIRTUAL_X;
+                goto lookupNext;
+            }
+            if (p->VDisplay > virtY) {
+                p->status = MODE_VIRTUAL_Y;
+                goto lookupNext;
+            }
+        }
+        /*
+         * Adjust virtual width and height if the mode is too large for the
+         * current values and if they are not fixed.
+         */
+        if (virtualX <= 0 && p->HDisplay > newVirtX)
+            newVirtX = _VIRTUALX(p->HDisplay);
+        if (virtualY <= 0 && p->VDisplay > newVirtY) {
+            if (maxHeight > 0 && p->VDisplay > maxHeight) {
+                p->status = MODE_VIRTUAL_Y;     /* ? */
+                goto lookupNext;
+            }
+            newVirtY = p->VDisplay;
+        }
+
+        /*
+         * If virtual resolution is to be increased, revalidate it.
+         */
+        if ((virtX != newVirtX) || (virtY != newVirtY)) {
+            if (linePitches != NULL) {
+                newLinePitch = -1;
+                for (i = 0; linePitches[i] != 0; i++) {
+                    if ((linePitches[i] >= newVirtX) &&
+                        (linePitches[i] >= linePitch) &&
+                        (linePitches[i] ==
+                         scanLineWidth(newVirtX, newVirtY, linePitches[i],
+                                       apertureSize, BankFormat, pitchInc))) {
+                        newLinePitch = linePitches[i];
+                        break;
+                    }
+                }
+            }
+            else {
+                if (linePitch < minPitch)
+                    linePitch = minPitch;
+                newLinePitch = scanLineWidth(newVirtX, newVirtY, linePitch,
+                                             apertureSize, BankFormat,
+                                             pitchInc);
+            }
+            if ((newLinePitch < minPitch) || (newLinePitch > maxPitch)) {
+                p->status = MODE_BAD_WIDTH;
+                goto lookupNext;
+            }
+
+            /*
+             * Check that the pixel area required by the new virtual height
+             * and line pitch isn't too large.
+             */
+            if (!xf86CheckModeSize(scrp, newLinePitch, newVirtX, newVirtY)) {
+                p->status = MODE_MEM_VIRT;
+                goto lookupNext;
+            }
+        }
+
+        if (scrp->ValidMode) {
+            /*
+             * Give the driver a final say, passing it the proposed virtual
+             * geometry.
+             */
+            scrp->virtualX = newVirtX;
+            scrp->virtualY = newVirtY;
+            scrp->displayWidth = newLinePitch;
+            p->status = (scrp->ValidMode) (scrp->scrnIndex, p, FALSE,
+                                           MODECHECK_FINAL);
+
+            if (p->status != MODE_OK) {
+                goto lookupNext;
+            }
+        }
+
+        /* Mode has passed all the tests */
+        virtX = newVirtX;
+        virtY = newVirtY;
+        linePitch = newLinePitch;
+        p->status = MODE_OK;
+        numModes++;
     }
 
     /*
@@ -1846,102 +1862,105 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
      * fix up if so.
      */
     if (inferred_virtual) {
-	int vx = 0, vy = 0;
-	for (p = scrp->modes; p; p = p->next) {
-	    if (p->HDisplay > vx && p->VDisplay > vy) {
-		vx = p->HDisplay;
-		vy = p->VDisplay;
-	    }
-	}
-	if (vx < virtX || vy < virtY) {
-	    const int types[] = {
-		M_T_BUILTIN | M_T_PREFERRED,
-		M_T_BUILTIN,
-		M_T_DRIVER | M_T_PREFERRED,
-		M_T_DRIVER,
-		0
-	    };
-	    const int ntypes = sizeof(types) / sizeof(int);
-	    int n;
-
-	    /* 
-	     * We did not find the estimated virtual size. So now we want to 
-	     * find the largest mode available, but we want to search in the
-	     * modes in the order of "types" listed above.
-	     */
-	    for (n = 0; n < ntypes; n++) {
-		int type = types[n];
-
-		vx = 0; vy = 0;
-		for (p = scrp->modes; p; p = p->next) {
-		    /* scan through the modes in the sort order above */
-		    if ((p->type & type) != type)
-			continue;
-		    if (p->HDisplay > vx && p->VDisplay > vy) {
-			vx = p->HDisplay;
-			vy = p->VDisplay;
-		    }
-		}
-		if (vx && vy)
-		    /* Found one */
-		    break;
-	    }
-	    xf86DrvMsg(scrp->scrnIndex, X_WARNING,
-		       "Shrinking virtual size estimate from %dx%d to %dx%d\n",
-		       virtX, virtY, vx, vy);
-	    virtX = _VIRTUALX(vx);
-	    virtY = vy;
-	    for (p = scrp->modes; p; p = p->next) {
-		if (numModes > 0) {
-		    if (p->HDisplay > virtX)
-			p->status = MODE_VIRTUAL_X;
-		    if (p->VDisplay > virtY)
-			p->status = MODE_VIRTUAL_Y;
-		    if (p->status != MODE_OK) {
-			numModes--;
-			printModeRejectMessage(scrp->scrnIndex, p, p->status);
-		    }
-		}
-	    }
-	    if (linePitches != NULL) {
-		for (i = 0; linePitches[i] != 0; i++) {
-		    if ((linePitches[i] >= virtX) &&
-			(linePitches[i] ==
-			scanLineWidth(virtX, virtY, linePitches[i],
-				      apertureSize, BankFormat, pitchInc))) {
-			linePitch = linePitches[i];
-			break;
-		    }
-		}
-	    } else {
-		linePitch = scanLineWidth(virtX, virtY, minPitch,
-					  apertureSize, BankFormat, pitchInc);
-	    }
-	}
+        int vx = 0, vy = 0;
+
+        for (p = scrp->modes; p; p = p->next) {
+            if (p->HDisplay > vx && p->VDisplay > vy) {
+                vx = p->HDisplay;
+                vy = p->VDisplay;
+            }
+        }
+        if (vx < virtX || vy < virtY) {
+            const int types[] = {
+                M_T_BUILTIN | M_T_PREFERRED,
+                M_T_BUILTIN,
+                M_T_DRIVER | M_T_PREFERRED,
+                M_T_DRIVER,
+                0
+            };
+            const int ntypes = sizeof(types) / sizeof(int);
+            int n;
+
+            /* 
+             * We did not find the estimated virtual size. So now we want to 
+             * find the largest mode available, but we want to search in the
+             * modes in the order of "types" listed above.
+             */
+            for (n = 0; n < ntypes; n++) {
+                int type = types[n];
+
+                vx = 0;
+                vy = 0;
+                for (p = scrp->modes; p; p = p->next) {
+                    /* scan through the modes in the sort order above */
+                    if ((p->type & type) != type)
+                        continue;
+                    if (p->HDisplay > vx && p->VDisplay > vy) {
+                        vx = p->HDisplay;
+                        vy = p->VDisplay;
+                    }
+                }
+                if (vx && vy)
+                    /* Found one */
+                    break;
+            }
+            xf86DrvMsg(scrp->scrnIndex, X_WARNING,
+                       "Shrinking virtual size estimate from %dx%d to %dx%d\n",
+                       virtX, virtY, vx, vy);
+            virtX = _VIRTUALX(vx);
+            virtY = vy;
+            for (p = scrp->modes; p; p = p->next) {
+                if (numModes > 0) {
+                    if (p->HDisplay > virtX)
+                        p->status = MODE_VIRTUAL_X;
+                    if (p->VDisplay > virtY)
+                        p->status = MODE_VIRTUAL_Y;
+                    if (p->status != MODE_OK) {
+                        numModes--;
+                        printModeRejectMessage(scrp->scrnIndex, p, p->status);
+                    }
+                }
+            }
+            if (linePitches != NULL) {
+                for (i = 0; linePitches[i] != 0; i++) {
+                    if ((linePitches[i] >= virtX) &&
+                        (linePitches[i] ==
+                         scanLineWidth(virtX, virtY, linePitches[i],
+                                       apertureSize, BankFormat, pitchInc))) {
+                        linePitch = linePitches[i];
+                        break;
+                    }
+                }
+            }
+            else {
+                linePitch = scanLineWidth(virtX, virtY, minPitch,
+                                          apertureSize, BankFormat, pitchInc);
+            }
+        }
     }
 
     /* Update the ScrnInfoRec parameters */
-    
+
     scrp->virtualX = virtX;
     scrp->virtualY = virtY;
     scrp->displayWidth = linePitch;
 
     if (numModes <= 0)
-	return 0;
-    
+        return 0;
+
     /* Make the mode list into a circular list by joining up the ends */
     p = scrp->modes;
     while (p->next != NULL)
-	p = p->next;
+        p = p->next;
     /* p is now the last mode on the list */
     p->next = scrp->modes;
     scrp->modes->prev = p;
 
     if (minHeight > 0 && virtY < minHeight) {
-	xf86DrvMsg(scrp->scrnIndex, X_ERROR,
-		   "Virtual height (%d) is too small for the hardware "
-		   "(min %d)\n", virtY, minHeight);
-	return -1;
+        xf86DrvMsg(scrp->scrnIndex, X_ERROR,
+                   "Virtual height (%d) is too small for the hardware "
+                   "(min %d)\n", virtY, minHeight);
+        return -1;
     }
 
     return numModes;
@@ -1959,26 +1978,27 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
  *  - doubly linked circular lists
  *
  */
- 
+
 void
-xf86DeleteMode(DisplayModePtr *modeList, DisplayModePtr mode)
+xf86DeleteMode(DisplayModePtr * modeList, DisplayModePtr mode)
 {
     /* Catch the easy/insane cases */
     if (modeList == NULL || *modeList == NULL || mode == NULL)
-	return;
+        return;
 
     /* If the mode is at the start of the list, move the start of the list */
     if (*modeList == mode)
-	*modeList = mode->next;
+        *modeList = mode->next;
 
     /* If mode is the only one on the list, set the list to NULL */
     if ((mode == mode->prev) && (mode == mode->next)) {
-	*modeList = NULL;
-    } else {
-	if ((mode->prev != NULL) && (mode->prev->next == mode))
-	    mode->prev->next = mode->next;
-	if ((mode->next != NULL) && (mode->next->prev == mode))
-	    mode->next->prev = mode->prev;
+        *modeList = NULL;
+    }
+    else {
+        if ((mode->prev != NULL) && (mode->prev->next == mode))
+            mode->prev->next = mode->next;
+        if ((mode->next != NULL) && (mode->next->prev == mode))
+            mode->next->prev = mode->prev;
     }
 
     free(mode->name);
@@ -1999,32 +2019,31 @@ xf86PruneDriverModes(ScrnInfoPtr scrp)
 
     p = scrp->modes;
     if (p == NULL)
-	return;
+        return;
 
     do {
-	if (!(first = scrp->modes))
-	    return;
-	n = p->next;
-	if (p->status != MODE_OK) {
-	    xf86DeleteMode(&(scrp->modes), p);
-	}
-	p = n;
+        if (!(first = scrp->modes))
+            return;
+        n = p->next;
+        if (p->status != MODE_OK) {
+            xf86DeleteMode(&(scrp->modes), p);
+        }
+        p = n;
     } while (p != NULL && p != first);
 
     /* modePool is no longer needed, turf it */
     while (scrp->modePool) {
-	/*
-	 * A modePool mode's prev field is used to hold a pointer to the
-	 * member of the scrp->modes list for which a match was considered.
-	 * Clear that pointer first, otherwise xf86DeleteMode might get 
-	 * confused 
-	 */
-	scrp->modePool->prev = NULL;
-	xf86DeleteMode(&scrp->modePool, scrp->modePool);
+        /*
+         * A modePool mode's prev field is used to hold a pointer to the
+         * member of the scrp->modes list for which a match was considered.
+         * Clear that pointer first, otherwise xf86DeleteMode might get 
+         * confused 
+         */
+        scrp->modePool->prev = NULL;
+        xf86DeleteMode(&scrp->modePool, scrp->modePool);
     }
 }
 
-
 /*
  * xf86SetCrtcForModes
  *
@@ -2045,18 +2064,18 @@ xf86SetCrtcForModes(ScrnInfoPtr scrp, int adjustFlags)
 
     p = scrp->modes;
     if (p == NULL)
-	return;
+        return;
 
     do {
-	xf86SetModeCrtc(p, adjustFlags);
-	DebugF("%sMode %s: %d (%d) %d %d (%d) %d %d (%d) %d %d (%d) %d\n",
-	       (p->type & M_T_DEFAULT) ? "Default " : "",
-	       p->name, p->CrtcHDisplay, p->CrtcHBlankStart,
-	       p->CrtcHSyncStart, p->CrtcHSyncEnd, p->CrtcHBlankEnd,
-	       p->CrtcHTotal, p->CrtcVDisplay, p->CrtcVBlankStart,
-	       p->CrtcVSyncStart, p->CrtcVSyncEnd, p->CrtcVBlankEnd,
-	       p->CrtcVTotal);
-	p = p->next;
+        xf86SetModeCrtc(p, adjustFlags);
+        DebugF("%sMode %s: %d (%d) %d %d (%d) %d %d (%d) %d %d (%d) %d\n",
+               (p->type & M_T_DEFAULT) ? "Default " : "",
+               p->name, p->CrtcHDisplay, p->CrtcHBlankStart,
+               p->CrtcHSyncStart, p->CrtcHSyncEnd, p->CrtcHBlankEnd,
+               p->CrtcHTotal, p->CrtcVDisplay, p->CrtcVBlankStart,
+               p->CrtcVSyncStart, p->CrtcVSyncEnd, p->CrtcVBlankEnd,
+               p->CrtcVTotal);
+        p = p->next;
     } while (p != NULL && p != scrp->modes);
 }
 
@@ -2068,63 +2087,65 @@ xf86PrintModes(ScrnInfoPtr scrp)
     const char *desc, *desc2, *prefix, *uprefix;
 
     if (scrp == NULL)
-	return;
+        return;
 
     xf86DrvMsg(scrp->scrnIndex, scrp->virtualFrom, "Virtual size is %dx%d "
-	       "(pitch %d)\n", scrp->virtualX, scrp->virtualY,
-	       scrp->displayWidth);
-    
+               "(pitch %d)\n", scrp->virtualX, scrp->virtualY,
+               scrp->displayWidth);
+
     p = scrp->modes;
     if (p == NULL)
-	return;
+        return;
 
     do {
-	desc = desc2 = "";
-	hsync = xf86ModeHSync(p);
-	refresh = xf86ModeVRefresh(p);
-	if (p->Flags & V_INTERLACE) {
-	    desc = " (I)";
-	}
-	if (p->Flags & V_DBLSCAN) {
-	    desc = " (D)";
-	}
-	if (p->VScan > 1) {
-	    desc2 = " (VScan)";
-	}
-	if (p->type & M_T_BUILTIN)
-	    prefix = "Built-in mode";
-	else if (p->type & M_T_DEFAULT)
-	    prefix = "Default mode";
-	else if (p->type & M_T_DRIVER)
-	    prefix = "Driver mode";
-	else
-	    prefix = "Mode";
-	if (p->type & M_T_USERDEF)
-	    uprefix = "*";
-	else
-	    uprefix = " ";
-	if (hsync == 0 || refresh == 0) {
-	    if (p->name)
-		xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
-			   "%s%s \"%s\"\n", uprefix, prefix, p->name);
-	    else
-		xf86DrvMsg(scrp->scrnIndex, X_PROBED,
-			   "%s%s %dx%d (unnamed)\n",
-			   uprefix, prefix, p->HDisplay, p->VDisplay);
-	} else if (p->Clock == p->SynthClock) {
-	    xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
-			"%s%s \"%s\": %.1f MHz, %.1f kHz, %.1f Hz%s%s\n",
-			uprefix, prefix, p->name, p->Clock / 1000.0,
-			hsync, refresh, desc, desc2);
-	} else {
-	    xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
-			"%s%s \"%s\": %.1f MHz (scaled from %.1f MHz), "
-			"%.1f kHz, %.1f Hz%s%s\n",
-			uprefix, prefix, p->name, p->Clock / 1000.0,
-			p->SynthClock / 1000.0, hsync, refresh, desc, desc2);
-	}
-	if (hsync != 0 && refresh != 0)
-	    xf86PrintModeline(scrp->scrnIndex,p);
-	p = p->next;
+        desc = desc2 = "";
+        hsync = xf86ModeHSync(p);
+        refresh = xf86ModeVRefresh(p);
+        if (p->Flags & V_INTERLACE) {
+            desc = " (I)";
+        }
+        if (p->Flags & V_DBLSCAN) {
+            desc = " (D)";
+        }
+        if (p->VScan > 1) {
+            desc2 = " (VScan)";
+        }
+        if (p->type & M_T_BUILTIN)
+            prefix = "Built-in mode";
+        else if (p->type & M_T_DEFAULT)
+            prefix = "Default mode";
+        else if (p->type & M_T_DRIVER)
+            prefix = "Driver mode";
+        else
+            prefix = "Mode";
+        if (p->type & M_T_USERDEF)
+            uprefix = "*";
+        else
+            uprefix = " ";
+        if (hsync == 0 || refresh == 0) {
+            if (p->name)
+                xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
+                           "%s%s \"%s\"\n", uprefix, prefix, p->name);
+            else
+                xf86DrvMsg(scrp->scrnIndex, X_PROBED,
+                           "%s%s %dx%d (unnamed)\n",
+                           uprefix, prefix, p->HDisplay, p->VDisplay);
+        }
+        else if (p->Clock == p->SynthClock) {
+            xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
+                       "%s%s \"%s\": %.1f MHz, %.1f kHz, %.1f Hz%s%s\n",
+                       uprefix, prefix, p->name, p->Clock / 1000.0,
+                       hsync, refresh, desc, desc2);
+        }
+        else {
+            xf86DrvMsg(scrp->scrnIndex, X_CONFIG,
+                       "%s%s \"%s\": %.1f MHz (scaled from %.1f MHz), "
+                       "%.1f kHz, %.1f Hz%s%s\n",
+                       uprefix, prefix, p->name, p->Clock / 1000.0,
+                       p->SynthClock / 1000.0, hsync, refresh, desc, desc2);
+        }
+        if (hsync != 0 && refresh != 0)
+            xf86PrintModeline(scrp->scrnIndex, p);
+        p = p->next;
     } while (p != NULL && p != scrp->modes);
 }