1 files changed, 323 insertions, 313 deletions

diff --git a/xorg-server/hw/xfree86/modes/xf86Modes.c b/xorg-server/hw/xfree86/modes/xf86Modes.c
index 49cc14992..2a6d26756 100644
--- a/xorg-server/hw/xfree86/modes/xf86Modes.c
+++ b/xorg-server/hw/xfree86/modes/xf86Modes.c
@@ -42,14 +42,14 @@ extern XF86ConfigPtr xf86configptr;
  * Calculates the horizontal sync rate of a mode.
  */
 double
-xf86ModeHSync(const DisplayModeRec *mode)
+xf86ModeHSync(const DisplayModeRec * mode)
 {
     double hsync = 0.0;
-    
+
     if (mode->HSync > 0.0)
-	    hsync = mode->HSync;
+        hsync = mode->HSync;
     else if (mode->HTotal > 0)
-	    hsync = (float)mode->Clock / (float)mode->HTotal;
+        hsync = (float) mode->Clock / (float) mode->HTotal;
 
     return hsync;
 }
@@ -58,51 +58,51 @@ xf86ModeHSync(const DisplayModeRec *mode)
  * Calculates the vertical refresh rate of a mode.
  */
 double
-xf86ModeVRefresh(const DisplayModeRec *mode)
+xf86ModeVRefresh(const DisplayModeRec * mode)
 {
     double refresh = 0.0;
 
     if (mode->VRefresh > 0.0)
-	refresh = mode->VRefresh;
+        refresh = mode->VRefresh;
     else if (mode->HTotal > 0 && mode->VTotal > 0) {
-	refresh = mode->Clock * 1000.0 / mode->HTotal / mode->VTotal;
-	if (mode->Flags & V_INTERLACE)
-	    refresh *= 2.0;
-	if (mode->Flags & V_DBLSCAN)
-	    refresh /= 2.0;
-	if (mode->VScan > 1)
-	    refresh /= (float)(mode->VScan);
+        refresh = mode->Clock * 1000.0 / mode->HTotal / mode->VTotal;
+        if (mode->Flags & V_INTERLACE)
+            refresh *= 2.0;
+        if (mode->Flags & V_DBLSCAN)
+            refresh /= 2.0;
+        if (mode->VScan > 1)
+            refresh /= (float) (mode->VScan);
     }
     return refresh;
 }
 
 int
-xf86ModeWidth (const DisplayModeRec *mode, Rotation rotation)
+xf86ModeWidth(const DisplayModeRec * mode, Rotation rotation)
 {
     switch (rotation & 0xf) {
     case RR_Rotate_0:
     case RR_Rotate_180:
-	return mode->HDisplay;
+        return mode->HDisplay;
     case RR_Rotate_90:
     case RR_Rotate_270:
-	return mode->VDisplay;
+        return mode->VDisplay;
     default:
-	return 0;
+        return 0;
     }
 }
 
 int
-xf86ModeHeight (const DisplayModeRec *mode, Rotation rotation)
+xf86ModeHeight(const DisplayModeRec * mode, Rotation rotation)
 {
     switch (rotation & 0xf) {
     case RR_Rotate_0:
     case RR_Rotate_180:
-	return mode->VDisplay;
+        return mode->VDisplay;
     case RR_Rotate_90:
     case RR_Rotate_270:
-	return mode->HDisplay;
+        return mode->HDisplay;
     default:
-	return 0;
+        return 0;
     }
 }
 
@@ -114,26 +114,26 @@ xf86ModeBandwidth(DisplayModePtr mode, int depth)
     int bytes_per_pixel = bits_to_bytes(depth);
 
     if (!mode->HTotal || !mode->VTotal || !mode->Clock)
-	return 0;
+        return 0;
 
     a_active = mode->HDisplay * mode->VDisplay;
     a_total = mode->HTotal * mode->VTotal;
     active_percent = a_active / a_total;
     pixels_per_second = active_percent * mode->Clock * 1000.0;
 
-    return (unsigned int)(pixels_per_second * bytes_per_pixel / (1024 * 1024));
+    return (unsigned int) (pixels_per_second * bytes_per_pixel / (1024 * 1024));
 }
 
 /** Sets a default mode name of <width>x<height> on a mode. */
 void
 xf86SetModeDefaultName(DisplayModePtr mode)
 {
-    Bool interlaced = !!(mode->Flags & V_INTERLACE);
+    Bool interlaced = ! !(mode->Flags & V_INTERLACE);
 
     free(mode->name);
 
     XNFasprintf(&mode->name, "%dx%d%s", mode->HDisplay, mode->VDisplay,
-		interlaced ? "i" : "");
+                interlaced ? "i" : "");
 }
 
 /*
@@ -146,40 +146,40 @@ void
 xf86SetModeCrtc(DisplayModePtr p, int adjustFlags)
 {
     if ((p == NULL) || ((p->type & M_T_CRTC_C) == M_T_BUILTIN))
-	return;
-
-    p->CrtcHDisplay             = p->HDisplay;
-    p->CrtcHSyncStart           = p->HSyncStart;
-    p->CrtcHSyncEnd             = p->HSyncEnd;
-    p->CrtcHTotal               = p->HTotal;
-    p->CrtcHSkew                = p->HSkew;
-    p->CrtcVDisplay             = p->VDisplay;
-    p->CrtcVSyncStart           = p->VSyncStart;
-    p->CrtcVSyncEnd             = p->VSyncEnd;
-    p->CrtcVTotal               = p->VTotal;
+        return;
+
+    p->CrtcHDisplay = p->HDisplay;
+    p->CrtcHSyncStart = p->HSyncStart;
+    p->CrtcHSyncEnd = p->HSyncEnd;
+    p->CrtcHTotal = p->HTotal;
+    p->CrtcHSkew = p->HSkew;
+    p->CrtcVDisplay = p->VDisplay;
+    p->CrtcVSyncStart = p->VSyncStart;
+    p->CrtcVSyncEnd = p->VSyncEnd;
+    p->CrtcVTotal = p->VTotal;
     if (p->Flags & V_INTERLACE) {
-	if (adjustFlags & INTERLACE_HALVE_V) {
-	    p->CrtcVDisplay         /= 2;
-	    p->CrtcVSyncStart       /= 2;
-	    p->CrtcVSyncEnd         /= 2;
-	    p->CrtcVTotal           /= 2;
-	}
-	/* Force interlaced modes to have an odd VTotal */
-	/* maybe we should only do this when INTERLACE_HALVE_V is set? */
-	p->CrtcVTotal |= 1;
+        if (adjustFlags & INTERLACE_HALVE_V) {
+            p->CrtcVDisplay /= 2;
+            p->CrtcVSyncStart /= 2;
+            p->CrtcVSyncEnd /= 2;
+            p->CrtcVTotal /= 2;
+        }
+        /* Force interlaced modes to have an odd VTotal */
+        /* maybe we should only do this when INTERLACE_HALVE_V is set? */
+        p->CrtcVTotal |= 1;
     }
 
     if (p->Flags & V_DBLSCAN) {
-        p->CrtcVDisplay         *= 2;
-        p->CrtcVSyncStart       *= 2;
-        p->CrtcVSyncEnd         *= 2;
-        p->CrtcVTotal           *= 2;
+        p->CrtcVDisplay *= 2;
+        p->CrtcVSyncStart *= 2;
+        p->CrtcVSyncEnd *= 2;
+        p->CrtcVTotal *= 2;
     }
     if (p->VScan > 1) {
-        p->CrtcVDisplay         *= p->VScan;
-        p->CrtcVSyncStart       *= p->VScan;
-        p->CrtcVSyncEnd         *= p->VScan;
-        p->CrtcVTotal           *= p->VScan;
+        p->CrtcVDisplay *= p->VScan;
+        p->CrtcVSyncStart *= p->VScan;
+        p->CrtcVSyncEnd *= p->VScan;
+        p->CrtcVTotal *= p->VScan;
     }
     p->CrtcVBlankStart = min(p->CrtcVSyncStart, p->CrtcVDisplay);
     p->CrtcVBlankEnd = max(p->CrtcVSyncEnd, p->CrtcVTotal);
@@ -194,7 +194,7 @@ xf86SetModeCrtc(DisplayModePtr p, int adjustFlags)
  * Allocates and returns a copy of pMode, including pointers within pMode.
  */
 DisplayModePtr
-xf86DuplicateMode(const DisplayModeRec *pMode)
+xf86DuplicateMode(const DisplayModeRec * pMode)
 {
     DisplayModePtr pNew;
 
@@ -204,9 +204,9 @@ xf86DuplicateMode(const DisplayModeRec *pMode)
     pNew->prev = NULL;
 
     if (pMode->name == NULL)
-	xf86SetModeDefaultName(pNew);
+        xf86SetModeDefaultName(pNew);
     else
-	pNew->name = xnfstrdup(pMode->name);
+        pNew->name = xnfstrdup(pMode->name);
 
     return pNew;
 }
@@ -224,20 +224,21 @@ xf86DuplicateModes(ScrnInfoPtr pScrn, DisplayModePtr modeList)
     DisplayModePtr mode;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	DisplayModePtr new;
-
-	new = xf86DuplicateMode(mode);
-
-	/* Insert pNew into modeList */
-	if (last) {
-	    last->next = new;
-	    new->prev = last;
-	} else {
-	    first = new;
-	    new->prev = NULL;
-	}
-	new->next = NULL;
-	last = new;
+        DisplayModePtr new;
+
+        new = xf86DuplicateMode(mode);
+
+        /* Insert pNew into modeList */
+        if (last) {
+            last->next = new;
+            new->prev = last;
+        }
+        else {
+            first = new;
+            new->prev = NULL;
+        }
+        new->next = NULL;
+        last = new;
     }
 
     return first;
@@ -250,25 +251,24 @@ xf86DuplicateModes(ScrnInfoPtr pScrn, DisplayModePtr modeList)
  * Crtc values set.  So, it's assumed that the other numbers are enough.
  */
 Bool
-xf86ModesEqual(const DisplayModeRec *pMode1, const DisplayModeRec *pMode2)
+xf86ModesEqual(const DisplayModeRec * pMode1, const DisplayModeRec * pMode2)
 {
-     if (pMode1->Clock == pMode2->Clock &&
-	 pMode1->HDisplay == pMode2->HDisplay &&
-	 pMode1->HSyncStart == pMode2->HSyncStart &&
-	 pMode1->HSyncEnd == pMode2->HSyncEnd &&
-	 pMode1->HTotal == pMode2->HTotal &&
-	 pMode1->HSkew == pMode2->HSkew &&
-	 pMode1->VDisplay == pMode2->VDisplay &&
-	 pMode1->VSyncStart == pMode2->VSyncStart &&
-	 pMode1->VSyncEnd == pMode2->VSyncEnd &&
-	 pMode1->VTotal == pMode2->VTotal &&
-	 pMode1->VScan == pMode2->VScan &&
-	 pMode1->Flags == pMode2->Flags)
-     {
-	return TRUE;
-     } else {
-	return FALSE;
-     }
+    if (pMode1->Clock == pMode2->Clock &&
+        pMode1->HDisplay == pMode2->HDisplay &&
+        pMode1->HSyncStart == pMode2->HSyncStart &&
+        pMode1->HSyncEnd == pMode2->HSyncEnd &&
+        pMode1->HTotal == pMode2->HTotal &&
+        pMode1->HSkew == pMode2->HSkew &&
+        pMode1->VDisplay == pMode2->VDisplay &&
+        pMode1->VSyncStart == pMode2->VSyncStart &&
+        pMode1->VSyncEnd == pMode2->VSyncEnd &&
+        pMode1->VTotal == pMode2->VTotal &&
+        pMode1->VScan == pMode2->VScan && pMode1->Flags == pMode2->Flags) {
+        return TRUE;
+    }
+    else {
+        return FALSE;
+    }
 }
 
 static void
@@ -309,54 +309,68 @@ xf86PrintModeline(int scrnIndex, DisplayModePtr mode)
 {
     char tmp[256];
     char *flags = xnfcalloc(1, 1);
+
 #define TBITS 6
-    const char tchar[TBITS+1] = "UezdPb";
+    const char tchar[TBITS + 1] = "UezdPb";
+
     int tbit[TBITS] = {
-	M_T_USERPREF, M_T_DRIVER, M_T_USERDEF,
-	M_T_DEFAULT, M_T_PREFERRED, M_T_BUILTIN
+        M_T_USERPREF, M_T_DRIVER, M_T_USERDEF,
+        M_T_DEFAULT, M_T_PREFERRED, M_T_BUILTIN
     };
-    char type[TBITS+2];   /* +1 for leading space */
+    char type[TBITS + 2];       /* +1 for leading space */
+
 #undef TBITS
     int tlen = 0;
 
     if (mode->type) {
-	int i;
+        int i;
 
-	type[tlen++] = ' ';
-	for (i = 0; tchar[i]; i++)
-	    if (mode->type & tbit[i])
-		type[tlen++] = tchar[i];
+        type[tlen++] = ' ';
+        for (i = 0; tchar[i]; i++)
+            if (mode->type & tbit[i])
+                type[tlen++] = tchar[i];
     }
     type[tlen] = '\0';
 
-    if (mode->HSkew) { 
-	snprintf(tmp, 256, "hskew %i", mode->HSkew); 
-	add(&flags, tmp);
+    if (mode->HSkew) {
+        snprintf(tmp, 256, "hskew %i", mode->HSkew);
+        add(&flags, tmp);
     }
-    if (mode->VScan) { 
-	snprintf(tmp, 256, "vscan %i", mode->VScan); 
-	add(&flags, tmp);
+    if (mode->VScan) {
+        snprintf(tmp, 256, "vscan %i", mode->VScan);
+        add(&flags, tmp);
     }
-    if (mode->Flags & V_INTERLACE) add(&flags, "interlace");
-    if (mode->Flags & V_CSYNC) add(&flags, "composite");
-    if (mode->Flags & V_DBLSCAN) add(&flags, "doublescan");
-    if (mode->Flags & V_BCAST) add(&flags, "bcast");
-    if (mode->Flags & V_PHSYNC) add(&flags, "+hsync");
-    if (mode->Flags & V_NHSYNC) add(&flags, "-hsync");
-    if (mode->Flags & V_PVSYNC) add(&flags, "+vsync");
-    if (mode->Flags & V_NVSYNC) add(&flags, "-vsync");
-    if (mode->Flags & V_PCSYNC) add(&flags, "+csync");
-    if (mode->Flags & V_NCSYNC) add(&flags, "-csync");
+    if (mode->Flags & V_INTERLACE)
+        add(&flags, "interlace");
+    if (mode->Flags & V_CSYNC)
+        add(&flags, "composite");
+    if (mode->Flags & V_DBLSCAN)
+        add(&flags, "doublescan");
+    if (mode->Flags & V_BCAST)
+        add(&flags, "bcast");
+    if (mode->Flags & V_PHSYNC)
+        add(&flags, "+hsync");
+    if (mode->Flags & V_NHSYNC)
+        add(&flags, "-hsync");
+    if (mode->Flags & V_PVSYNC)
+        add(&flags, "+vsync");
+    if (mode->Flags & V_NVSYNC)
+        add(&flags, "-vsync");
+    if (mode->Flags & V_PCSYNC)
+        add(&flags, "+csync");
+    if (mode->Flags & V_NCSYNC)
+        add(&flags, "-csync");
 #if 0
-    if (mode->Flags & V_CLKDIV2) add(&flags, "vclk/2");
+    if (mode->Flags & V_CLKDIV2)
+        add(&flags, "vclk/2");
 #endif
     xf86DrvMsg(scrnIndex, X_INFO,
-	       "Modeline \"%s\"x%.01f  %6.2f  %i %i %i %i  %i %i %i %i%s"
-	       " (%.01f kHz%s)\n",
-	       mode->name, mode->VRefresh, mode->Clock/1000.,
-	       mode->HDisplay, mode->HSyncStart, mode->HSyncEnd, mode->HTotal,
-	       mode->VDisplay, mode->VSyncStart, mode->VSyncEnd, mode->VTotal,
-	       flags, xf86ModeHSync(mode), type);
+               "Modeline \"%s\"x%.01f  %6.2f  %i %i %i %i  %i %i %i %i%s"
+               " (%.01f kHz%s)\n",
+               mode->name, mode->VRefresh, mode->Clock / 1000.,
+               mode->HDisplay, mode->HSyncStart, mode->HSyncEnd, mode->HTotal,
+               mode->VDisplay, mode->VSyncStart, mode->VSyncEnd, mode->VTotal,
+               flags, xf86ModeHSync(mode), type);
     free(flags);
 }
 
@@ -369,19 +383,18 @@ xf86PrintModeline(int scrnIndex, DisplayModePtr mode)
  * \bug only V_INTERLACE and V_DBLSCAN are supported.  Is that enough?
  */
 void
-xf86ValidateModesFlags(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			    int flags)
+xf86ValidateModesFlags(ScrnInfoPtr pScrn, DisplayModePtr modeList, int flags)
 {
     DisplayModePtr mode;
 
     if (flags == (V_INTERLACE | V_DBLSCAN))
-	return;
+        return;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	if (mode->Flags & V_INTERLACE && !(flags & V_INTERLACE))
-	    mode->status = MODE_NO_INTERLACE;
-	if (mode->Flags & V_DBLSCAN && !(flags & V_DBLSCAN))
-	    mode->status = MODE_NO_DBLESCAN;
+        if (mode->Flags & V_INTERLACE && !(flags & V_INTERLACE))
+            mode->status = MODE_NO_INTERLACE;
+        if (mode->Flags & V_DBLSCAN && !(flags & V_DBLSCAN))
+            mode->status = MODE_NO_DBLESCAN;
     }
 }
 
@@ -392,39 +405,39 @@ xf86ValidateModesFlags(ScrnInfoPtr pScrn, DisplayModePtr modeList,
  */
 void
 xf86ValidateModesSize(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			  int maxX, int maxY, int maxPitch)
+                      int maxX, int maxY, int maxPitch)
 {
     DisplayModePtr mode;
 
     if (maxPitch <= 0)
-	    maxPitch = MAXINT;
+        maxPitch = MAXINT;
     if (maxX <= 0)
-	    maxX = MAXINT;
+        maxX = MAXINT;
     if (maxY <= 0)
-	    maxY = MAXINT;
+        maxY = MAXINT;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	if ((xf86ModeWidth(mode, RR_Rotate_0) > maxPitch ||
-	     xf86ModeWidth(mode, RR_Rotate_0) > maxX ||
-	     xf86ModeHeight(mode, RR_Rotate_0) > maxY) &&
-	    (xf86ModeWidth(mode, RR_Rotate_90) > maxPitch ||
-	     xf86ModeWidth(mode, RR_Rotate_90) > maxX ||
-	     xf86ModeHeight(mode, RR_Rotate_90) > maxY)) {
-	    if (xf86ModeWidth(mode, RR_Rotate_0) > maxPitch ||
-		xf86ModeWidth(mode, RR_Rotate_90) > maxPitch)
-		mode->status = MODE_BAD_WIDTH;
-
-	    if (xf86ModeWidth(mode, RR_Rotate_0) > maxX ||
-		xf86ModeWidth(mode, RR_Rotate_90) > maxX)
-		mode->status = MODE_VIRTUAL_X;
-
-	    if (xf86ModeHeight(mode, RR_Rotate_0) > maxY ||
-		xf86ModeHeight(mode, RR_Rotate_90) > maxY)
-		mode->status = MODE_VIRTUAL_Y;
-	}
-
-	if (mode->next == modeList)
-	    break;
+        if ((xf86ModeWidth(mode, RR_Rotate_0) > maxPitch ||
+             xf86ModeWidth(mode, RR_Rotate_0) > maxX ||
+             xf86ModeHeight(mode, RR_Rotate_0) > maxY) &&
+            (xf86ModeWidth(mode, RR_Rotate_90) > maxPitch ||
+             xf86ModeWidth(mode, RR_Rotate_90) > maxX ||
+             xf86ModeHeight(mode, RR_Rotate_90) > maxY)) {
+            if (xf86ModeWidth(mode, RR_Rotate_0) > maxPitch ||
+                xf86ModeWidth(mode, RR_Rotate_90) > maxPitch)
+                mode->status = MODE_BAD_WIDTH;
+
+            if (xf86ModeWidth(mode, RR_Rotate_0) > maxX ||
+                xf86ModeWidth(mode, RR_Rotate_90) > maxX)
+                mode->status = MODE_VIRTUAL_X;
+
+            if (xf86ModeHeight(mode, RR_Rotate_0) > maxY ||
+                xf86ModeHeight(mode, RR_Rotate_90) > maxY)
+                mode->status = MODE_VIRTUAL_Y;
+        }
+
+        if (mode->next == modeList)
+            break;
     }
 }
 
@@ -435,39 +448,39 @@ xf86ValidateModesSize(ScrnInfoPtr pScrn, DisplayModePtr modeList,
  * \param modeList doubly-linked list of modes.
  */
 void
-xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			  MonPtr mon)
+xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList, MonPtr mon)
 {
     DisplayModePtr mode;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	Bool bad;
-	int i;
-
-	bad = TRUE;
-	for (i = 0; i < mon->nHsync; i++) {
-	    if (xf86ModeHSync(mode) >= mon->hsync[i].lo * (1-SYNC_TOLERANCE) &&
-		xf86ModeHSync(mode) <= mon->hsync[i].hi * (1+SYNC_TOLERANCE))
-	    {
-		bad = FALSE;
-	    }
-	}
-	if (bad)
-	    mode->status = MODE_HSYNC;
-
-	bad = TRUE;
-	for (i = 0; i < mon->nVrefresh; i++) {
-	    if (xf86ModeVRefresh(mode) >= mon->vrefresh[i].lo * (1-SYNC_TOLERANCE) &&
-		xf86ModeVRefresh(mode) <= mon->vrefresh[i].hi * (1+SYNC_TOLERANCE))
-	    {
-		bad = FALSE;
-	    }
-	}
-	if (bad)
-	    mode->status = MODE_VSYNC;
-
-	if (mode->next == modeList)
-	    break;
+        Bool bad;
+        int i;
+
+        bad = TRUE;
+        for (i = 0; i < mon->nHsync; i++) {
+            if (xf86ModeHSync(mode) >= mon->hsync[i].lo * (1 - SYNC_TOLERANCE)
+                && xf86ModeHSync(mode) <=
+                mon->hsync[i].hi * (1 + SYNC_TOLERANCE)) {
+                bad = FALSE;
+            }
+        }
+        if (bad)
+            mode->status = MODE_HSYNC;
+
+        bad = TRUE;
+        for (i = 0; i < mon->nVrefresh; i++) {
+            if (xf86ModeVRefresh(mode) >=
+                mon->vrefresh[i].lo * (1 - SYNC_TOLERANCE) &&
+                xf86ModeVRefresh(mode) <=
+                mon->vrefresh[i].hi * (1 + SYNC_TOLERANCE)) {
+                bad = FALSE;
+            }
+        }
+        if (bad)
+            mode->status = MODE_VSYNC;
+
+        if (mode->next == modeList)
+            break;
     }
 }
 
@@ -481,22 +494,23 @@ xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList,
  */
 void
 xf86ValidateModesClocks(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			    int *min, int *max, int n_ranges)
+                        int *min, int *max, int n_ranges)
 {
     DisplayModePtr mode;
     int i;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	Bool good = FALSE;
-	for (i = 0; i < n_ranges; i++) {
-	    if (mode->Clock >= min[i] * (1-SYNC_TOLERANCE) &&
-		mode->Clock <= max[i] * (1+SYNC_TOLERANCE)) {
-		good = TRUE;
-		break;
-	    }
-	}
-	if (!good)
-	    mode->status = MODE_CLOCK_RANGE;
+        Bool good = FALSE;
+
+        for (i = 0; i < n_ranges; i++) {
+            if (mode->Clock >= min[i] * (1 - SYNC_TOLERANCE) &&
+                mode->Clock <= max[i] * (1 + SYNC_TOLERANCE)) {
+                good = TRUE;
+                break;
+            }
+        }
+        if (!good)
+            mode->status = MODE_CLOCK_RANGE;
     }
 }
 
@@ -518,25 +532,24 @@ xf86ValidateModesUserConfig(ScrnInfoPtr pScrn, DisplayModePtr modeList)
     DisplayModePtr mode;
 
     if (pScrn->display->modes[0] == NULL)
-	return;
+        return;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	int i;
-	Bool good = FALSE;
-
-	for (i = 0; pScrn->display->modes[i] != NULL; i++) {
-	    if (strncmp(pScrn->display->modes[i], mode->name,
-			strlen(pScrn->display->modes[i])) == 0) {
-		good = TRUE;
-		break;
-	    }
-	}
-	if (!good)
-	    mode->status = MODE_BAD;
+        int i;
+        Bool good = FALSE;
+
+        for (i = 0; pScrn->display->modes[i] != NULL; i++) {
+            if (strncmp(pScrn->display->modes[i], mode->name,
+                        strlen(pScrn->display->modes[i])) == 0) {
+                good = TRUE;
+                break;
+            }
+        }
+        if (!good)
+            mode->status = MODE_BAD;
     }
 }
 
-
 /**
  * Marks as bad any modes exceeding the given bandwidth.
  *
@@ -546,25 +559,25 @@ xf86ValidateModesUserConfig(ScrnInfoPtr pScrn, DisplayModePtr modeList)
  */
 void
 xf86ValidateModesBandwidth(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			   unsigned int bandwidth, int depth)
+                           unsigned int bandwidth, int depth)
 {
     DisplayModePtr mode;
 
     for (mode = modeList; mode != NULL; mode = mode->next) {
-	if (xf86ModeBandwidth(mode, depth) > bandwidth)
-	    mode->status = MODE_BANDWIDTH;
+        if (xf86ModeBandwidth(mode, depth) > bandwidth)
+            mode->status = MODE_BANDWIDTH;
     }
 }
 
 Bool
-xf86ModeIsReduced(const DisplayModeRec *mode)
+xf86ModeIsReduced(const DisplayModeRec * mode)
 {
     if ((((mode->HDisplay * 5 / 4) & ~0x07) > mode->HTotal) &&
         ((mode->HTotal - mode->HDisplay) == 160) &&
-	((mode->HSyncEnd - mode->HDisplay) == 80) &&
-	((mode->HSyncEnd - mode->HSyncStart) == 32) &&
-	((mode->VSyncStart - mode->VDisplay) == 3))
-	return TRUE;
+        ((mode->HSyncEnd - mode->HDisplay) == 80) &&
+        ((mode->HSyncEnd - mode->HSyncStart) == 32) &&
+        ((mode->VSyncStart - mode->VDisplay) == 3))
+        return TRUE;
     return FALSE;
 }
 
@@ -577,8 +590,8 @@ void
 xf86ValidateModesReducedBlanking(ScrnInfoPtr pScrn, DisplayModePtr modeList)
 {
     for (; modeList != NULL; modeList = modeList->next)
-	if (xf86ModeIsReduced(modeList))
-	    modeList->status = MODE_NO_REDUCED;
+        if (xf86ModeIsReduced(modeList))
+            modeList->status = MODE_NO_REDUCED;
 }
 
 /**
@@ -589,31 +602,32 @@ xf86ValidateModesReducedBlanking(ScrnInfoPtr pScrn, DisplayModePtr modeList)
  *	  printed.
  */
 void
-xf86PruneInvalidModes(ScrnInfoPtr pScrn, DisplayModePtr *modeList,
-			  Bool verbose)
+xf86PruneInvalidModes(ScrnInfoPtr pScrn, DisplayModePtr * modeList,
+                      Bool verbose)
 {
     DisplayModePtr mode;
 
     for (mode = *modeList; mode != NULL;) {
-	DisplayModePtr next = mode->next, first = *modeList;
-
-	if (mode->status != MODE_OK) {
-	    if (verbose) {
-		const char *type = "";
-		if (mode->type & M_T_BUILTIN)
-		    type = "built-in ";
-		else if (mode->type & M_T_DEFAULT)
-		    type = "default ";
-		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-			   "Not using %smode \"%s\" (%s)\n", type, mode->name,
-			   xf86ModeStatusToString(mode->status));
-	    }
-	    xf86DeleteMode(modeList, mode);
-	}
-
-	if (next == first)
-	    break;
-	mode = next;
+        DisplayModePtr next = mode->next, first = *modeList;
+
+        if (mode->status != MODE_OK) {
+            if (verbose) {
+                const char *type = "";
+
+                if (mode->type & M_T_BUILTIN)
+                    type = "built-in ";
+                else if (mode->type & M_T_DEFAULT)
+                    type = "default ";
+                xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                           "Not using %smode \"%s\" (%s)\n", type, mode->name,
+                           xf86ModeStatusToString(mode->status));
+            }
+            xf86DeleteMode(modeList, mode);
+        }
+
+        if (next == first)
+            break;
+        mode = next;
     }
 }
 
@@ -626,16 +640,16 @@ DisplayModePtr
 xf86ModesAdd(DisplayModePtr modes, DisplayModePtr new)
 {
     if (modes == NULL)
-	return new;
+        return new;
 
     if (new) {
-	DisplayModePtr mode = modes;
+        DisplayModePtr mode = modes;
 
-	while (mode->next)
-	    mode = mode->next;
+        while (mode->next)
+            mode = mode->next;
 
-	mode->next = new;
-	new->prev = mode;
+        mode->next = new;
+        new->prev = mode;
     }
 
     return modes;
@@ -645,42 +659,40 @@ xf86ModesAdd(DisplayModePtr modes, DisplayModePtr new)
  * Build a mode list from a list of config file modes
  */
 static DisplayModePtr
-xf86GetConfigModes (XF86ConfModeLinePtr conf_mode)
+xf86GetConfigModes(XF86ConfModeLinePtr conf_mode)
 {
-    DisplayModePtr  head = NULL, prev = NULL, mode;
-    
-    for (; conf_mode; conf_mode = (XF86ConfModeLinePtr) conf_mode->list.next)
-    {
+    DisplayModePtr head = NULL, prev = NULL, mode;
+
+    for (; conf_mode; conf_mode = (XF86ConfModeLinePtr) conf_mode->list.next) {
         mode = calloc(1, sizeof(DisplayModeRec));
-	if (!mode)
-	    continue;
-        mode->name       = xstrdup(conf_mode->ml_identifier);
-	if (!mode->name)
-	{
-	    free(mode);
-	    continue;
-	}
-	mode->type       = 0;
-        mode->Clock      = conf_mode->ml_clock;
-        mode->HDisplay   = conf_mode->ml_hdisplay;
+        if (!mode)
+            continue;
+        mode->name = xstrdup(conf_mode->ml_identifier);
+        if (!mode->name) {
+            free(mode);
+            continue;
+        }
+        mode->type = 0;
+        mode->Clock = conf_mode->ml_clock;
+        mode->HDisplay = conf_mode->ml_hdisplay;
         mode->HSyncStart = conf_mode->ml_hsyncstart;
-        mode->HSyncEnd   = conf_mode->ml_hsyncend;
-        mode->HTotal     = conf_mode->ml_htotal;
-        mode->VDisplay   = conf_mode->ml_vdisplay;
+        mode->HSyncEnd = conf_mode->ml_hsyncend;
+        mode->HTotal = conf_mode->ml_htotal;
+        mode->VDisplay = conf_mode->ml_vdisplay;
         mode->VSyncStart = conf_mode->ml_vsyncstart;
-        mode->VSyncEnd   = conf_mode->ml_vsyncend;
-        mode->VTotal     = conf_mode->ml_vtotal;
-        mode->Flags      = conf_mode->ml_flags;
-        mode->HSkew      = conf_mode->ml_hskew;
-        mode->VScan      = conf_mode->ml_vscan;
+        mode->VSyncEnd = conf_mode->ml_vsyncend;
+        mode->VTotal = conf_mode->ml_vtotal;
+        mode->Flags = conf_mode->ml_flags;
+        mode->HSkew = conf_mode->ml_hskew;
+        mode->VScan = conf_mode->ml_vscan;
 
         mode->prev = prev;
-	mode->next = NULL;
-	if (prev)
-	    prev->next = mode;
-	else
-	    head = mode;
-	prev = mode;
+        mode->next = NULL;
+        if (prev)
+            prev->next = mode;
+        else
+            head = mode;
+        prev = mode;
     }
     return head;
 }
@@ -689,49 +701,47 @@ xf86GetConfigModes (XF86ConfModeLinePtr conf_mode)
  * Build a mode list from a monitor configuration
  */
 DisplayModePtr
-xf86GetMonitorModes (ScrnInfoPtr pScrn, XF86ConfMonitorPtr conf_monitor)
+xf86GetMonitorModes(ScrnInfoPtr pScrn, XF86ConfMonitorPtr conf_monitor)
 {
-    DisplayModePtr	    modes = NULL;
-    XF86ConfModesLinkPtr    modes_link;
-    
+    DisplayModePtr modes = NULL;
+    XF86ConfModesLinkPtr modes_link;
+
     if (!conf_monitor)
-	return NULL;
+        return NULL;
 
     /*
      * first we collect the mode lines from the UseModes directive
      */
-    for (modes_link = conf_monitor->mon_modes_sect_lst; 
-	 modes_link; 
-	 modes_link = modes_link->list.next)
-    {
-	/* If this modes link hasn't been resolved, go look it up now */
-	if (!modes_link->ml_modes)
-	    modes_link->ml_modes = xf86findModes (modes_link->ml_modes_str, 
-						  xf86configptr->conf_modes_lst);
-	if (modes_link->ml_modes)
-	    modes = xf86ModesAdd (modes,
-				  xf86GetConfigModes (modes_link->ml_modes->mon_modeline_lst));
+    for (modes_link = conf_monitor->mon_modes_sect_lst;
+         modes_link; modes_link = modes_link->list.next) {
+        /* If this modes link hasn't been resolved, go look it up now */
+        if (!modes_link->ml_modes)
+            modes_link->ml_modes = xf86findModes(modes_link->ml_modes_str,
+                                                 xf86configptr->conf_modes_lst);
+        if (modes_link->ml_modes)
+            modes = xf86ModesAdd(modes,
+                                 xf86GetConfigModes(modes_link->ml_modes->
+                                                    mon_modeline_lst));
     }
 
-    return xf86ModesAdd (modes,
-			 xf86GetConfigModes (conf_monitor->mon_modeline_lst));
+    return xf86ModesAdd(modes,
+                        xf86GetConfigModes(conf_monitor->mon_modeline_lst));
 }
 
 /**
  * Build a mode list containing all of the default modes
  */
 DisplayModePtr
-xf86GetDefaultModes (void)
+xf86GetDefaultModes(void)
 {
-    DisplayModePtr  head = NULL, mode;
-    int		    i;
-
-    for (i = 0; i < xf86NumDefaultModes; i++)
-    {
-	const DisplayModeRec	*defMode = &xf86DefaultModes[i];
-	
-	mode = xf86DuplicateMode(defMode);
-	head = xf86ModesAdd(head, mode);
+    DisplayModePtr head = NULL, mode;
+    int i;
+
+    for (i = 0; i < xf86NumDefaultModes; i++) {
+        const DisplayModeRec *defMode = &xf86DefaultModes[i];
+
+        mode = xf86DuplicateMode(defMode);
+        head = xf86ModesAdd(head, mode);
     }
     return head;
 }
@@ -752,19 +762,19 @@ xf86PruneDuplicateModes(DisplayModePtr modes)
 {
     DisplayModePtr m, n, o;
 
-top:
+ top:
     for (m = modes; m; m = m->next) {
-	for (n = m->next; n; n = o) {
-	    o = n->next;
-	    if (xf86ModesEqual(m, n)) {
-		if (n->type & M_T_PREFERRED) {
-		    xf86DeleteMode(&modes, m);
-		    goto top;
-		}
-		else
-		    xf86DeleteMode(&modes, n);
-	    }
-	}
+        for (n = m->next; n; n = o) {
+            o = n->next;
+            if (xf86ModesEqual(m, n)) {
+                if (n->type & M_T_PREFERRED) {
+                    xf86DeleteMode(&modes, m);
+                    goto top;
+                }
+                else
+                    xf86DeleteMode(&modes, n);
+            }
+        }
     }
 
     return modes;