libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

13 files changed, 5414 insertions, 5541 deletions

diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.c b/xorg-server/hw/xfree86/modes/xf86Crtc.c
index da9db3460..6d5e92f12 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.c
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.c
@@ -55,26 +55,24 @@
 int xf86CrtcConfigPrivateIndex = -1;
 
 void
-xf86CrtcConfigInit (ScrnInfoPtr scrn,
-		    const xf86CrtcConfigFuncsRec *funcs)
+xf86CrtcConfigInit(ScrnInfoPtr scrn, const xf86CrtcConfigFuncsRec * funcs)
 {
-    xf86CrtcConfigPtr	config;
-    
+    xf86CrtcConfigPtr config;
+
     if (xf86CrtcConfigPrivateIndex == -1)
-	xf86CrtcConfigPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
-    config = xnfcalloc (1, sizeof (xf86CrtcConfigRec));
+        xf86CrtcConfigPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
+    config = xnfcalloc(1, sizeof(xf86CrtcConfigRec));
 
     config->funcs = funcs;
 
     scrn->privates[xf86CrtcConfigPrivateIndex].ptr = config;
 }
- 
+
 void
-xf86CrtcSetSizeRange (ScrnInfoPtr scrn,
-		      int minWidth, int minHeight,
-		      int maxWidth, int maxHeight)
+xf86CrtcSetSizeRange(ScrnInfoPtr scrn,
+                     int minWidth, int minHeight, int maxWidth, int maxHeight)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
 
     config->minWidth = minWidth;
     config->minHeight = minHeight;
@@ -86,15 +84,14 @@ xf86CrtcSetSizeRange (ScrnInfoPtr scrn,
  * Crtc functions
  */
 xf86CrtcPtr
-xf86CrtcCreate (ScrnInfoPtr		scrn,
-		const xf86CrtcFuncsRec	*funcs)
+xf86CrtcCreate(ScrnInfoPtr scrn, const xf86CrtcFuncsRec * funcs)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CrtcPtr		crtc, *crtcs;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcPtr crtc, *crtcs;
 
-    crtc = calloc(sizeof (xf86CrtcRec), 1);
+    crtc = calloc(sizeof(xf86CrtcRec), 1);
     if (!crtc)
-	return NULL;
+        return NULL;
     crtc->version = XF86_CRTC_VERSION;
     crtc->scrn = scrn;
     crtc->funcs = funcs;
@@ -103,9 +100,9 @@ xf86CrtcCreate (ScrnInfoPtr		scrn,
 #endif
     crtc->rotation = RR_Rotate_0;
     crtc->desiredRotation = RR_Rotate_0;
-    pixman_transform_init_identity (&crtc->crtc_to_framebuffer);
-    pixman_f_transform_init_identity (&crtc->f_crtc_to_framebuffer);
-    pixman_f_transform_init_identity (&crtc->f_framebuffer_to_crtc);
+    pixman_transform_init_identity(&crtc->crtc_to_framebuffer);
+    pixman_f_transform_init_identity(&crtc->f_crtc_to_framebuffer);
+    pixman_f_transform_init_identity(&crtc->f_framebuffer_to_crtc);
     crtc->filter = NULL;
     crtc->params = NULL;
     crtc->nparams = 0;
@@ -114,28 +111,27 @@ xf86CrtcCreate (ScrnInfoPtr		scrn,
     crtc->transform_in_use = FALSE;
     crtc->transformPresent = FALSE;
     crtc->desiredTransformPresent = FALSE;
-    memset (&crtc->bounds, '\0', sizeof (crtc->bounds));
+    memset(&crtc->bounds, '\0', sizeof(crtc->bounds));
 
     /* Preallocate gamma at a sensible size. */
     crtc->gamma_size = 256;
-    crtc->gamma_red = malloc(3 * crtc->gamma_size * sizeof (CARD16));
+    crtc->gamma_red = malloc(3 * crtc->gamma_size * sizeof(CARD16));
     if (!crtc->gamma_red) {
-	free(crtc);
-	return NULL;
+        free(crtc);
+        return NULL;
     }
     crtc->gamma_green = crtc->gamma_red + crtc->gamma_size;
     crtc->gamma_blue = crtc->gamma_green + crtc->gamma_size;
 
     if (xf86_config->crtc)
-	crtcs = realloc(xf86_config->crtc,
-			  (xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));
+        crtcs = realloc(xf86_config->crtc,
+                        (xf86_config->num_crtc + 1) * sizeof(xf86CrtcPtr));
     else
-	crtcs = malloc((xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));
-    if (!crtcs)
-    {
-	free(crtc->gamma_red);
-	free(crtc);
-	return NULL;
+        crtcs = malloc((xf86_config->num_crtc + 1) * sizeof(xf86CrtcPtr));
+    if (!crtcs) {
+        free(crtc->gamma_red);
+        free(crtc);
+        return NULL;
     }
     xf86_config->crtc = crtcs;
     xf86_config->crtc[xf86_config->num_crtc++] = crtc;
@@ -143,146 +139,140 @@ xf86CrtcCreate (ScrnInfoPtr		scrn,
 }
 
 void
-xf86CrtcDestroy (xf86CrtcPtr crtc)
+xf86CrtcDestroy(xf86CrtcPtr crtc)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
-    int			c;
-    
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+    int c;
+
     (*crtc->funcs->destroy) (crtc);
     for (c = 0; c < xf86_config->num_crtc; c++)
-	if (xf86_config->crtc[c] == crtc)
-	{
-	    memmove (&xf86_config->crtc[c],
-		     &xf86_config->crtc[c+1],
-		     ((xf86_config->num_crtc - (c + 1)) * sizeof(void*)));
-	    xf86_config->num_crtc--;
-	    break;
-	}
+        if (xf86_config->crtc[c] == crtc) {
+            memmove(&xf86_config->crtc[c],
+                    &xf86_config->crtc[c + 1],
+                    ((xf86_config->num_crtc - (c + 1)) * sizeof(void *)));
+            xf86_config->num_crtc--;
+            break;
+        }
     free(crtc->params);
     free(crtc->gamma_red);
     free(crtc);
 }
 
-
 /**
  * Return whether any outputs are connected to the specified pipe
  */
 
 Bool
-xf86CrtcInUse (xf86CrtcPtr crtc)
+xf86CrtcInUse(xf86CrtcPtr crtc)
 {
-    ScrnInfoPtr		pScrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			o;
-    
+    ScrnInfoPtr pScrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int o;
+
     for (o = 0; o < xf86_config->num_output; o++)
-	if (xf86_config->output[o]->crtc == crtc)
-	    return TRUE;
+        if (xf86_config->output[o]->crtc == crtc)
+            return TRUE;
     return FALSE;
 }
 
 void
-xf86CrtcSetScreenSubpixelOrder (ScreenPtr pScreen)
+xf86CrtcSetScreenSubpixelOrder(ScreenPtr pScreen)
 {
-    int			subpixel_order = SubPixelUnknown;
-    Bool		has_none = FALSE;
-    ScrnInfoPtr		scrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c, o;
+    int subpixel_order = SubPixelUnknown;
+    Bool has_none = FALSE;
+    ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c, o;
 
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
-	
-	for (o = 0; o < xf86_config->num_output; o++)
-	{
-	    xf86OutputPtr   output = xf86_config->output[o];
-
-	    if (output->crtc == crtc)
-	    {
-		switch (output->subpixel_order) {
-		case SubPixelNone:
-		    has_none = TRUE;
-		    break;
-		case SubPixelUnknown:
-		    break;
-		default:
-		    subpixel_order = output->subpixel_order;
-		    break;
-		}
-	    }
-	    if (subpixel_order != SubPixelUnknown)
-		break;
-	}
-	if (subpixel_order != SubPixelUnknown)
-	{
-	    static const int circle[4] = {
-		SubPixelHorizontalRGB,
-		SubPixelVerticalRGB,
-		SubPixelHorizontalBGR,
-		SubPixelVerticalBGR,
-	    };
-	    int	rotate;
-	    int c;
-	    for (rotate = 0; rotate < 4; rotate++)
-		if (crtc->rotation & (1 << rotate))
-		    break;
-	    for (c = 0; c < 4; c++)
-		if (circle[c] == subpixel_order)
-		    break;
-	    c = (c + rotate) & 0x3;
-	    if ((crtc->rotation & RR_Reflect_X) && !(c & 1))
-		c ^= 2;
-	    if ((crtc->rotation & RR_Reflect_Y) && (c & 1))
-		c ^= 2;
-	    subpixel_order = circle[c];
-	    break;
-	}
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+        for (o = 0; o < xf86_config->num_output; o++) {
+            xf86OutputPtr output = xf86_config->output[o];
+
+            if (output->crtc == crtc) {
+                switch (output->subpixel_order) {
+                case SubPixelNone:
+                    has_none = TRUE;
+                    break;
+                case SubPixelUnknown:
+                    break;
+                default:
+                    subpixel_order = output->subpixel_order;
+                    break;
+                }
+            }
+            if (subpixel_order != SubPixelUnknown)
+                break;
+        }
+        if (subpixel_order != SubPixelUnknown) {
+            static const int circle[4] = {
+                SubPixelHorizontalRGB,
+                SubPixelVerticalRGB,
+                SubPixelHorizontalBGR,
+                SubPixelVerticalBGR,
+            };
+            int rotate;
+            int c;
+
+            for (rotate = 0; rotate < 4; rotate++)
+                if (crtc->rotation & (1 << rotate))
+                    break;
+            for (c = 0; c < 4; c++)
+                if (circle[c] == subpixel_order)
+                    break;
+            c = (c + rotate) & 0x3;
+            if ((crtc->rotation & RR_Reflect_X) && !(c & 1))
+                c ^= 2;
+            if ((crtc->rotation & RR_Reflect_Y) && (c & 1))
+                c ^= 2;
+            subpixel_order = circle[c];
+            break;
+        }
     }
     if (subpixel_order == SubPixelUnknown && has_none)
-	subpixel_order = SubPixelNone;
-    PictureSetSubpixelOrder (pScreen, subpixel_order);
+        subpixel_order = SubPixelNone;
+    PictureSetSubpixelOrder(pScreen, subpixel_order);
 }
 
 /**
  * Sets the given video mode on the given crtc
  */
 Bool
-xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
-			  RRTransformPtr transform, int x, int y)
-{
-    ScrnInfoPtr		scrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			i;
-    Bool		ret = FALSE;
-    Bool		didLock = FALSE;
-    DisplayModePtr	adjusted_mode;
-    DisplayModeRec	saved_mode;
-    int			saved_x, saved_y;
-    Rotation		saved_rotation;
-    RRTransformRec	saved_transform;
-    Bool		saved_transform_present;
-
-    crtc->enabled = xf86CrtcInUse (crtc);
+xf86CrtcSetModeTransform(xf86CrtcPtr crtc, DisplayModePtr mode,
+                         Rotation rotation, RRTransformPtr transform, int x,
+                         int y)
+{
+    ScrnInfoPtr scrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int i;
+    Bool ret = FALSE;
+    Bool didLock = FALSE;
+    DisplayModePtr adjusted_mode;
+    DisplayModeRec saved_mode;
+    int saved_x, saved_y;
+    Rotation saved_rotation;
+    RRTransformRec saved_transform;
+    Bool saved_transform_present;
+
+    crtc->enabled = xf86CrtcInUse(crtc);
 
     /* We only hit this if someone explicitly sends a "disabled" modeset. */
-    if (!crtc->enabled)
-    {
-	/* Check everything for stuff that should be off. */
-	xf86DisableUnusedFunctions(scrn);
-	return TRUE;
+    if (!crtc->enabled) {
+        /* Check everything for stuff that should be off. */
+        xf86DisableUnusedFunctions(scrn);
+        return TRUE;
     }
 
     adjusted_mode = xf86DuplicateMode(mode);
 
-
     saved_mode = crtc->mode;
     saved_x = crtc->x;
     saved_y = crtc->y;
     saved_rotation = crtc->rotation;
     if (crtc->transformPresent) {
-	RRTransformInit (&saved_transform);
-	RRTransformCopy (&saved_transform, &crtc->transform);
+        RRTransformInit(&saved_transform);
+        RRTransformCopy(&saved_transform, &crtc->transform);
     }
     saved_transform_present = crtc->transformPresent;
 
@@ -294,48 +284,49 @@ xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotati
     crtc->y = y;
     crtc->rotation = rotation;
     if (transform) {
-	RRTransformCopy (&crtc->transform, transform);
-	crtc->transformPresent = TRUE;
-    } else
-	crtc->transformPresent = FALSE;
+        RRTransformCopy(&crtc->transform, transform);
+        crtc->transformPresent = TRUE;
+    }
+    else
+        crtc->transformPresent = FALSE;
 
     if (crtc->funcs->set_mode_major) {
-	ret = crtc->funcs->set_mode_major(crtc, mode, rotation, x, y);
-	goto done;
+        ret = crtc->funcs->set_mode_major(crtc, mode, rotation, x, y);
+        goto done;
     }
 
-    didLock = crtc->funcs->lock (crtc);
+    didLock = crtc->funcs->lock(crtc);
     /* Pass our mode to the outputs and the CRTC to give them a chance to
      * adjust it according to limitations or output properties, and also
      * a chance to reject the mode entirely.
      */
     for (i = 0; i < xf86_config->num_output; i++) {
-	xf86OutputPtr output = xf86_config->output[i];
+        xf86OutputPtr output = xf86_config->output[i];
 
-	if (output->crtc != crtc)
-	    continue;
+        if (output->crtc != crtc)
+            continue;
 
-	if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {
-	    goto done;
-	}
+        if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {
+            goto done;
+        }
     }
 
     if (!crtc->funcs->mode_fixup(crtc, mode, adjusted_mode)) {
-	goto done;
+        goto done;
     }
 
-    if (!xf86CrtcRotate (crtc))
-	goto done;
+    if (!xf86CrtcRotate(crtc))
+        goto done;
 
     /* Prepare the outputs and CRTCs before setting the mode. */
     for (i = 0; i < xf86_config->num_output; i++) {
-	xf86OutputPtr output = xf86_config->output[i];
+        xf86OutputPtr output = xf86_config->output[i];
 
-	if (output->crtc != crtc)
-	    continue;
+        if (output->crtc != crtc)
+            continue;
 
-	/* Disable the output as the first thing we do. */
-	output->funcs->prepare(output);
+        /* Disable the output as the first thing we do. */
+        output->funcs->prepare(output);
     }
 
     crtc->funcs->prepare(crtc);
@@ -344,51 +335,52 @@ xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotati
      * on the DPLL.
      */
     crtc->funcs->mode_set(crtc, mode, adjusted_mode, crtc->x, crtc->y);
-    for (i = 0; i < xf86_config->num_output; i++) 
-    {
-	xf86OutputPtr output = xf86_config->output[i];
-	if (output->crtc == crtc)
-	    output->funcs->mode_set(output, mode, adjusted_mode);
+    for (i = 0; i < xf86_config->num_output; i++) {
+        xf86OutputPtr output = xf86_config->output[i];
+
+        if (output->crtc == crtc)
+            output->funcs->mode_set(output, mode, adjusted_mode);
     }
 
     /* Only upload when needed, to avoid unneeded delays. */
     if (!crtc->active && crtc->funcs->gamma_set)
-	crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
-                                            crtc->gamma_blue, crtc->gamma_size);
+        crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
+                               crtc->gamma_blue, crtc->gamma_size);
 
     /* Now, enable the clocks, plane, pipe, and outputs that we set up. */
     crtc->funcs->commit(crtc);
-    for (i = 0; i < xf86_config->num_output; i++) 
-    {
-	xf86OutputPtr output = xf86_config->output[i];
-	if (output->crtc == crtc)
-	    output->funcs->commit(output);
+    for (i = 0; i < xf86_config->num_output; i++) {
+        xf86OutputPtr output = xf86_config->output[i];
+
+        if (output->crtc == crtc)
+            output->funcs->commit(output);
     }
 
     ret = TRUE;
 
-done:
+ done:
     if (ret) {
-	crtc->active = TRUE;
-	if (scrn->pScreen)
-	    xf86CrtcSetScreenSubpixelOrder (scrn->pScreen);
-	if (scrn->ModeSet)
-	    scrn->ModeSet(scrn);
-    } else {
-	crtc->x = saved_x;
-	crtc->y = saved_y;
-	crtc->rotation = saved_rotation;
-	crtc->mode = saved_mode;
-	if (saved_transform_present)
-	    RRTransformCopy (&crtc->transform, &saved_transform);
-	crtc->transformPresent = saved_transform_present;
+        crtc->active = TRUE;
+        if (scrn->pScreen)
+            xf86CrtcSetScreenSubpixelOrder(scrn->pScreen);
+        if (scrn->ModeSet)
+            scrn->ModeSet(scrn);
+    }
+    else {
+        crtc->x = saved_x;
+        crtc->y = saved_y;
+        crtc->rotation = saved_rotation;
+        crtc->mode = saved_mode;
+        if (saved_transform_present)
+            RRTransformCopy(&crtc->transform, &saved_transform);
+        crtc->transformPresent = saved_transform_present;
     }
 
     free(adjusted_mode->name);
     free(adjusted_mode);
 
     if (didLock)
-	crtc->funcs->unlock (crtc);
+        crtc->funcs->unlock(crtc);
 
     return ret;
 }
@@ -398,31 +390,31 @@ done:
  * a transform
  */
 Bool
-xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
-		 int x, int y)
+xf86CrtcSetMode(xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
+                int x, int y)
 {
-    return xf86CrtcSetModeTransform (crtc, mode, rotation, NULL, x, y);
+    return xf86CrtcSetModeTransform(crtc, mode, rotation, NULL, x, y);
 }
 
 /**
  * Pans the screen, does not change the mode
  */
 void
-xf86CrtcSetOrigin (xf86CrtcPtr crtc, int x, int y)
+xf86CrtcSetOrigin(xf86CrtcPtr crtc, int x, int y)
 {
     ScrnInfoPtr scrn = crtc->scrn;
 
     crtc->x = x;
     crtc->y = y;
     if (crtc->funcs->set_origin) {
-	if (!xf86CrtcRotate (crtc))
-	    return;
-	crtc->funcs->set_origin (crtc, x, y);
-	if (scrn->ModeSet)
-	    scrn->ModeSet(scrn);
+        if (!xf86CrtcRotate(crtc))
+            return;
+        crtc->funcs->set_origin(crtc, x, y);
+        if (scrn->ModeSet)
+            scrn->ModeSet(scrn);
     }
     else
-	xf86CrtcSetMode (crtc, &crtc->mode, crtc->rotation, x, y);
+        xf86CrtcSetMode(crtc, &crtc->mode, crtc->rotation, x, y);
 }
 
 /*
@@ -450,22 +442,22 @@ typedef enum {
 } OutputOpts;
 
 static OptionInfoRec xf86OutputOptions[] = {
-    {OPTION_PREFERRED_MODE, "PreferredMode",	OPTV_STRING,  {0}, FALSE },
-    {OPTION_POSITION,	    "Position",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_BELOW,	    "Below",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_RIGHT_OF,	    "RightOf",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_ABOVE,	    "Above",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_LEFT_OF,	    "LeftOf",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_ENABLE,	    "Enable",		OPTV_BOOLEAN, {0}, FALSE },
-    {OPTION_DISABLE,	    "Disable",		OPTV_BOOLEAN, {0}, FALSE },
-    {OPTION_MIN_CLOCK,	    "MinClock",		OPTV_FREQ,    {0}, FALSE },
-    {OPTION_MAX_CLOCK,	    "MaxClock",		OPTV_FREQ,    {0}, FALSE },
-    {OPTION_IGNORE,	    "Ignore",		OPTV_BOOLEAN, {0}, FALSE },
-    {OPTION_ROTATE,	    "Rotate",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_PANNING,	    "Panning",		OPTV_STRING,  {0}, FALSE },
-    {OPTION_PRIMARY,	    "Primary",		OPTV_BOOLEAN, {0}, FALSE },
-    {OPTION_DEFAULT_MODES,  "DefaultModes",	OPTV_BOOLEAN, {0}, FALSE },
-    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },
+    {OPTION_PREFERRED_MODE, "PreferredMode", OPTV_STRING, {0}, FALSE},
+    {OPTION_POSITION, "Position", OPTV_STRING, {0}, FALSE},
+    {OPTION_BELOW, "Below", OPTV_STRING, {0}, FALSE},
+    {OPTION_RIGHT_OF, "RightOf", OPTV_STRING, {0}, FALSE},
+    {OPTION_ABOVE, "Above", OPTV_STRING, {0}, FALSE},
+    {OPTION_LEFT_OF, "LeftOf", OPTV_STRING, {0}, FALSE},
+    {OPTION_ENABLE, "Enable", OPTV_BOOLEAN, {0}, FALSE},
+    {OPTION_DISABLE, "Disable", OPTV_BOOLEAN, {0}, FALSE},
+    {OPTION_MIN_CLOCK, "MinClock", OPTV_FREQ, {0}, FALSE},
+    {OPTION_MAX_CLOCK, "MaxClock", OPTV_FREQ, {0}, FALSE},
+    {OPTION_IGNORE, "Ignore", OPTV_BOOLEAN, {0}, FALSE},
+    {OPTION_ROTATE, "Rotate", OPTV_STRING, {0}, FALSE},
+    {OPTION_PANNING, "Panning", OPTV_STRING, {0}, FALSE},
+    {OPTION_PRIMARY, "Primary", OPTV_BOOLEAN, {0}, FALSE},
+    {OPTION_DEFAULT_MODES, "DefaultModes", OPTV_BOOLEAN, {0}, FALSE},
+    {-1, NULL, OPTV_NONE, {0}, FALSE},
 };
 
 enum {
@@ -473,144 +465,138 @@ enum {
 };
 
 static OptionInfoRec xf86DeviceOptions[] = {
-    {OPTION_MODEDEBUG,	    "ModeDebug",	OPTV_BOOLEAN,  {0}, FALSE },
-    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },
+    {OPTION_MODEDEBUG, "ModeDebug", OPTV_BOOLEAN, {0}, FALSE},
+    {-1, NULL, OPTV_NONE, {0}, FALSE},
 };
 
 static void
-xf86OutputSetMonitor (xf86OutputPtr output)
+xf86OutputSetMonitor(xf86OutputPtr output)
 {
-    char    *option_name;
-    const char    *monitor;
+    char *option_name;
+    const char *monitor;
 
     if (!output->name)
-	return;
+        return;
 
     free(output->options);
 
-    output->options = xnfalloc (sizeof (xf86OutputOptions));
-    memcpy (output->options, xf86OutputOptions, sizeof (xf86OutputOptions));
+    output->options = xnfalloc(sizeof(xf86OutputOptions));
+    memcpy(output->options, xf86OutputOptions, sizeof(xf86OutputOptions));
 
     XNFasprintf(&option_name, "monitor-%s", output->name);
-    monitor = xf86findOptionValue (output->scrn->options, option_name);
+    monitor = xf86findOptionValue(output->scrn->options, option_name);
     if (!monitor)
-	monitor = output->name;
+        monitor = output->name;
     else
-	xf86MarkOptionUsedByName (output->scrn->options, option_name);
+        xf86MarkOptionUsedByName(output->scrn->options, option_name);
     free(option_name);
-    output->conf_monitor = xf86findMonitor (monitor,
-					    xf86configptr->conf_monitor_lst);
+    output->conf_monitor = xf86findMonitor(monitor,
+                                           xf86configptr->conf_monitor_lst);
     /*
      * Find the monitor section of the screen and use that
      */
     if (!output->conf_monitor && output->use_screen_monitor)
-	output->conf_monitor = xf86findMonitor (output->scrn->monitor->id,
-						xf86configptr->conf_monitor_lst);
-    if (output->conf_monitor)
-    {
-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
-		    "Output %s using monitor section %s\n",
-		    output->name, output->conf_monitor->mon_identifier);
-	xf86ProcessOptions (output->scrn->scrnIndex,
-			    output->conf_monitor->mon_option_lst,
-			    output->options);
+        output->conf_monitor = xf86findMonitor(output->scrn->monitor->id,
+                                               xf86configptr->conf_monitor_lst);
+    if (output->conf_monitor) {
+        xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+                   "Output %s using monitor section %s\n",
+                   output->name, output->conf_monitor->mon_identifier);
+        xf86ProcessOptions(output->scrn->scrnIndex,
+                           output->conf_monitor->mon_option_lst,
+                           output->options);
     }
     else
-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
-		    "Output %s has no monitor section\n",
-		    output->name);
+        xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+                   "Output %s has no monitor section\n", output->name);
 }
 
 static Bool
-xf86OutputEnabled (xf86OutputPtr output, Bool strict)
+xf86OutputEnabled(xf86OutputPtr output, Bool strict)
 {
-    Bool    enable, disable;
+    Bool enable, disable;
 
     /* check to see if this output was enabled in the config file */
-    if (xf86GetOptValBool (output->options, OPTION_ENABLE, &enable) && enable)
-    {
-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
-		    "Output %s enabled by config file\n", output->name);
-	return TRUE;
+    if (xf86GetOptValBool(output->options, OPTION_ENABLE, &enable) && enable) {
+        xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+                   "Output %s enabled by config file\n", output->name);
+        return TRUE;
     }
     /* or if this output was disabled in the config file */
-    if (xf86GetOptValBool (output->options, OPTION_DISABLE, &disable) && disable)
-    {
-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
-		    "Output %s disabled by config file\n", output->name);
-	return FALSE;
+    if (xf86GetOptValBool(output->options, OPTION_DISABLE, &disable) && disable) {
+        xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+                   "Output %s disabled by config file\n", output->name);
+        return FALSE;
     }
 
     /* If not, try to only light up the ones we know are connected */
     if (strict) {
-	enable = output->status == XF86OutputStatusConnected;
+        enable = output->status == XF86OutputStatusConnected;
     }
     /* But if that fails, try to light up even outputs we're unsure of */
     else {
-	enable = output->status != XF86OutputStatusDisconnected;
+        enable = output->status != XF86OutputStatusDisconnected;
     }
 
-    xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
-    	    "Output %s %sconnected\n", output->name, enable ? "" : "dis");
+    xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+               "Output %s %sconnected\n", output->name, enable ? "" : "dis");
     return enable;
 }
 
 static Bool
-xf86OutputIgnored (xf86OutputPtr    output)
+xf86OutputIgnored(xf86OutputPtr output)
 {
-    return xf86ReturnOptValBool (output->options, OPTION_IGNORE, FALSE);
+    return xf86ReturnOptValBool(output->options, OPTION_IGNORE, FALSE);
 }
 
 static const char *direction[4] = {
-    "normal", 
-    "left", 
-    "inverted", 
+    "normal",
+    "left",
+    "inverted",
     "right"
 };
 
 static Rotation
-xf86OutputInitialRotation (xf86OutputPtr output)
+xf86OutputInitialRotation(xf86OutputPtr output)
 {
-    char    *rotate_name = xf86GetOptValString (output->options, 
-						OPTION_ROTATE);
-    int	    i;
+    char *rotate_name = xf86GetOptValString(output->options,
+                                            OPTION_ROTATE);
+    int i;
 
     if (!rotate_name) {
-	if (output->initial_rotation)
-	    return output->initial_rotation;
-	return RR_Rotate_0;
+        if (output->initial_rotation)
+            return output->initial_rotation;
+        return RR_Rotate_0;
     }
-    
+
     for (i = 0; i < 4; i++)
-	if (xf86nameCompare (direction[i], rotate_name) == 0)
-	    return 1 << i;
+        if (xf86nameCompare(direction[i], rotate_name) == 0)
+            return 1 << i;
     return RR_Rotate_0;
 }
 
 xf86OutputPtr
-xf86OutputCreate (ScrnInfoPtr		    scrn,
-		  const xf86OutputFuncsRec  *funcs,
-		  const char		    *name)
+xf86OutputCreate(ScrnInfoPtr scrn,
+                 const xf86OutputFuncsRec * funcs, const char *name)
 {
-    xf86OutputPtr	output, *outputs;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			len;
-    Bool		primary;
+    xf86OutputPtr output, *outputs;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int len;
+    Bool primary;
 
     if (name)
-	len = strlen (name) + 1;
+        len = strlen(name) + 1;
     else
-	len = 0;
+        len = 0;
 
-    output = calloc(sizeof (xf86OutputRec) + len, 1);
+    output = calloc(sizeof(xf86OutputRec) + len, 1);
     if (!output)
-	return NULL;
+        return NULL;
     output->scrn = scrn;
     output->funcs = funcs;
-    if (name)
-    {
-	output->name = (char *) (output + 1);
-	strcpy (output->name, name);
+    if (name) {
+        output->name = (char *) (output + 1);
+        strcpy(output->name, name);
     }
     output->subpixel_order = SubPixelUnknown;
     /*
@@ -620,39 +606,34 @@ xf86OutputCreate (ScrnInfoPtr		    scrn,
 #ifdef RANDR_12_INTERFACE
     output->randr_output = NULL;
 #endif
-    if (name)
-    {
-	xf86OutputSetMonitor (output);
-	if (xf86OutputIgnored (output))
-	{
-	    free(output);
-	    return FALSE;
-	}
-    }
-    
-    
+    if (name) {
+        xf86OutputSetMonitor(output);
+        if (xf86OutputIgnored(output)) {
+            free(output);
+            return FALSE;
+        }
+    }
+
     if (xf86_config->output)
-	outputs = realloc(xf86_config->output,
-			  (xf86_config->num_output + 1) * sizeof (xf86OutputPtr));
+        outputs = realloc(xf86_config->output,
+                          (xf86_config->num_output +
+                           1) * sizeof(xf86OutputPtr));
     else
-	outputs = malloc((xf86_config->num_output + 1) * sizeof (xf86OutputPtr));
-    if (!outputs)
-    {
-	free(output);
-	return NULL;
+        outputs = malloc((xf86_config->num_output + 1) * sizeof(xf86OutputPtr));
+    if (!outputs) {
+        free(output);
+        return NULL;
     }
 
     xf86_config->output = outputs;
 
-    if (xf86GetOptValBool (output->options, OPTION_PRIMARY, &primary) && primary)
-    {
-	memmove(xf86_config->output + 1, xf86_config->output,
-		xf86_config->num_output * sizeof (xf86OutputPtr));
-	xf86_config->output[0] = output;
+    if (xf86GetOptValBool(output->options, OPTION_PRIMARY, &primary) && primary) {
+        memmove(xf86_config->output + 1, xf86_config->output,
+                xf86_config->num_output * sizeof(xf86OutputPtr));
+        xf86_config->output[0] = output;
     }
-    else
-    {
-	xf86_config->output[xf86_config->num_output] = output;
+    else {
+        xf86_config->output[xf86_config->num_output] = output;
     }
 
     xf86_config->num_output++;
@@ -661,53 +642,51 @@ xf86OutputCreate (ScrnInfoPtr		    scrn,
 }
 
 Bool
-xf86OutputRename (xf86OutputPtr output, const char *name)
+xf86OutputRename(xf86OutputPtr output, const char *name)
 {
-    char    *newname = strdup(name);
-    
+    char *newname = strdup(name);
+
     if (!newname)
-	return FALSE;	/* so sorry... */
-    
+        return FALSE;           /* so sorry... */
+
     if (output->name && output->name != (char *) (output + 1))
-	free(output->name);
+        free(output->name);
     output->name = newname;
-    xf86OutputSetMonitor (output);
-    if (xf86OutputIgnored (output))
-	return FALSE;
+    xf86OutputSetMonitor(output);
+    if (xf86OutputIgnored(output))
+        return FALSE;
     return TRUE;
 }
 
 void
-xf86OutputUseScreenMonitor (xf86OutputPtr output, Bool use_screen_monitor)
+xf86OutputUseScreenMonitor(xf86OutputPtr output, Bool use_screen_monitor)
 {
-    if (use_screen_monitor != output->use_screen_monitor)
-    {
-	output->use_screen_monitor = use_screen_monitor;
-	xf86OutputSetMonitor (output);
+    if (use_screen_monitor != output->use_screen_monitor) {
+        output->use_screen_monitor = use_screen_monitor;
+        xf86OutputSetMonitor(output);
     }
 }
 
 void
-xf86OutputDestroy (xf86OutputPtr output)
+xf86OutputDestroy(xf86OutputPtr output)
 {
-    ScrnInfoPtr		scrn = output->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o;
-    
+    ScrnInfoPtr scrn = output->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
+
     (*output->funcs->destroy) (output);
     while (output->probed_modes)
-	xf86DeleteMode (&output->probed_modes, output->probed_modes);
+        xf86DeleteMode(&output->probed_modes, output->probed_modes);
     for (o = 0; o < xf86_config->num_output; o++)
-	if (xf86_config->output[o] == output)
-	{
-	    memmove (&xf86_config->output[o],
-		     &xf86_config->output[o+1],
-		     ((xf86_config->num_output - (o + 1)) * sizeof(void*)));
-	    xf86_config->num_output--;
-	    break;
-	}
+        if (xf86_config->output[o] == output) {
+            memmove(&xf86_config->output[o],
+                    &xf86_config->output[o + 1],
+                    ((xf86_config->num_output - (o + 1)) * sizeof(void *)));
+            xf86_config->num_output--;
+            break;
+        }
     if (output->name && output->name != (char *) (output + 1))
-	free(output->name);
+        free(output->name);
     free(output);
 }
 
@@ -715,18 +694,18 @@ xf86OutputDestroy (xf86OutputPtr output)
  * Called during CreateScreenResources to hook up RandR
  */
 static Bool
-xf86CrtcCreateScreenResources (ScreenPtr screen)
+xf86CrtcCreateScreenResources(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
 
     screen->CreateScreenResources = config->CreateScreenResources;
-    
-    if (!(*screen->CreateScreenResources)(screen))
-	return FALSE;
 
-    if (!xf86RandR12CreateScreenResources (screen))
-	return FALSE;
+    if (!(*screen->CreateScreenResources) (screen))
+        return FALSE;
+
+    if (!xf86RandR12CreateScreenResources(screen))
+        return FALSE;
 
     return TRUE;
 }
@@ -735,31 +714,29 @@ xf86CrtcCreateScreenResources (ScreenPtr screen)
  * Clean up config on server reset
  */
 static Bool
-xf86CrtcCloseScreen (int index, ScreenPtr screen)
+xf86CrtcCloseScreen(int index, ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o, c;
-    
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o, c;
+
     screen->CloseScreen = config->CloseScreen;
 
-    xf86RotateCloseScreen (screen);
+    xf86RotateCloseScreen(screen);
 
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
 
-	output->randr_output = NULL;
+        output->randr_output = NULL;
     }
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr	crtc = config->crtc[c];
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
 
-	crtc->randr_crtc = NULL;
+        crtc->randr_crtc = NULL;
     }
-    xf86RandR12CloseScreen (screen);
+    xf86RandR12CloseScreen(screen);
 
-    return screen->CloseScreen (index, screen);
+    return screen->CloseScreen(index, screen);
 }
 
 /*
@@ -770,37 +747,36 @@ int
 #else
 Bool
 #endif
-xf86CrtcScreenInit (ScreenPtr screen)
+xf86CrtcScreenInit(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     /* Rotation */
-    xf86DrvMsg(scrn->scrnIndex, X_INFO, "RandR 1.2 enabled, ignore the following RandR disabled message.\n");
-    xf86DisableRandR(); /* Disable old RandR extension support */
-    xf86RandR12Init (screen);
+    xf86DrvMsg(scrn->scrnIndex, X_INFO,
+               "RandR 1.2 enabled, ignore the following RandR disabled message.\n");
+    xf86DisableRandR();         /* Disable old RandR extension support */
+    xf86RandR12Init(screen);
 
     /* support all rotations if every crtc has the shadow alloc funcs */
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = config->crtc[c];
-	if (!crtc->funcs->shadow_allocate || !crtc->funcs->shadow_create)
-	    break;
-    }
-    if (c == config->num_crtc)
-    {
-	xf86RandR12SetRotations (screen, RR_Rotate_0 | RR_Rotate_90 |
-				 RR_Rotate_180 | RR_Rotate_270 |
-				 RR_Reflect_X | RR_Reflect_Y);
-	xf86RandR12SetTransformSupport (screen, TRUE);
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        if (!crtc->funcs->shadow_allocate || !crtc->funcs->shadow_create)
+            break;
     }
-    else
-    {
-	xf86RandR12SetRotations (screen, RR_Rotate_0);
-	xf86RandR12SetTransformSupport (screen, FALSE);
+    if (c == config->num_crtc) {
+        xf86RandR12SetRotations(screen, RR_Rotate_0 | RR_Rotate_90 |
+                                RR_Rotate_180 | RR_Rotate_270 |
+                                RR_Reflect_X | RR_Reflect_Y);
+        xf86RandR12SetTransformSupport(screen, TRUE);
+    }
+    else {
+        xf86RandR12SetRotations(screen, RR_Rotate_0);
+        xf86RandR12SetTransformSupport(screen, FALSE);
     }
-    
+
     /* Wrap CreateScreenResources so we can initialize the RandR code */
     config->CreateScreenResources = screen->CreateScreenResources;
     screen->CreateScreenResources = xf86CrtcCreateScreenResources;
@@ -810,7 +786,7 @@ xf86CrtcScreenInit (ScreenPtr screen)
 
     /* This might still be marked wrapped from a previous generation */
     config->BlockHandler = NULL;
-    
+
 #ifdef XFreeXDGA
     _xf86_di_dga_init_internal(screen);
 #endif
@@ -822,205 +798,198 @@ xf86CrtcScreenInit (ScreenPtr screen)
 }
 
 static DisplayModePtr
-xf86DefaultMode (xf86OutputPtr output, int width, int height)
-{
-    DisplayModePtr  target_mode = NULL;
-    DisplayModePtr  mode;
-    int		    target_diff = 0;
-    int		    target_preferred = 0;
-    int		    mm_height;
-    
+xf86DefaultMode(xf86OutputPtr output, int width, int height)
+{
+    DisplayModePtr target_mode = NULL;
+    DisplayModePtr mode;
+    int target_diff = 0;
+    int target_preferred = 0;
+    int mm_height;
+
     mm_height = output->mm_height;
     if (!mm_height)
-	mm_height = (768 * 25.4) / DEFAULT_DPI;
+        mm_height = (768 * 25.4) / DEFAULT_DPI;
     /*
      * Pick a mode closest to DEFAULT_DPI
      */
-    for (mode = output->probed_modes; mode; mode = mode->next)
-    {
-	int	    dpi;
-	int	    preferred = (((mode->type & M_T_PREFERRED) != 0) +
-				 ((mode->type & M_T_USERPREF) != 0));
-	int	    diff;
-
-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
-	    xf86ModeHeight (mode, output->initial_rotation) > height)
-	    continue;
-	
-	/* yes, use VDisplay here, not xf86ModeHeight */
-	dpi = (mode->VDisplay * 254) / (mm_height * 10);
-	diff = dpi - DEFAULT_DPI;
-	diff = diff < 0 ? -diff : diff;
-	if (target_mode == NULL || (preferred > target_preferred) ||
-	    (preferred == target_preferred && diff < target_diff))
-	{
-	    target_mode = mode;
-	    target_diff = diff;
-	    target_preferred = preferred;
-	}
+    for (mode = output->probed_modes; mode; mode = mode->next) {
+        int dpi;
+        int preferred = (((mode->type & M_T_PREFERRED) != 0) +
+                         ((mode->type & M_T_USERPREF) != 0));
+        int diff;
+
+        if (xf86ModeWidth(mode, output->initial_rotation) > width ||
+            xf86ModeHeight(mode, output->initial_rotation) > height)
+            continue;
+
+        /* yes, use VDisplay here, not xf86ModeHeight */
+        dpi = (mode->VDisplay * 254) / (mm_height * 10);
+        diff = dpi - DEFAULT_DPI;
+        diff = diff < 0 ? -diff : diff;
+        if (target_mode == NULL || (preferred > target_preferred) ||
+            (preferred == target_preferred && diff < target_diff)) {
+            target_mode = mode;
+            target_diff = diff;
+            target_preferred = preferred;
+        }
     }
     return target_mode;
 }
 
 static DisplayModePtr
-xf86ClosestMode (xf86OutputPtr output, 
-		 DisplayModePtr match, Rotation match_rotation,
-		 int width, int height)
-{
-    DisplayModePtr  target_mode = NULL;
-    DisplayModePtr  mode;
-    int		    target_diff = 0;
-    
+xf86ClosestMode(xf86OutputPtr output,
+                DisplayModePtr match, Rotation match_rotation,
+                int width, int height)
+{
+    DisplayModePtr target_mode = NULL;
+    DisplayModePtr mode;
+    int target_diff = 0;
+
     /*
      * Pick a mode closest to the specified mode
      */
-    for (mode = output->probed_modes; mode; mode = mode->next)
-    {
-	int	    dx, dy;
-	int	    diff;
-
-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
-	    xf86ModeHeight (mode, output->initial_rotation) > height)
-	    continue;
-	
-	/* exact matches are preferred */
-	if (output->initial_rotation == match_rotation &&
-	    xf86ModesEqual (mode, match))
-	    return mode;
-	
-	dx = xf86ModeWidth (match, match_rotation) - xf86ModeWidth (mode, output->initial_rotation);
-	dy = xf86ModeHeight (match, match_rotation) - xf86ModeHeight (mode, output->initial_rotation);
-	diff = dx * dx + dy * dy;
-	if (target_mode == NULL || diff < target_diff)
-	{
-	    target_mode = mode;
-	    target_diff = diff;
-	}
+    for (mode = output->probed_modes; mode; mode = mode->next) {
+        int dx, dy;
+        int diff;
+
+        if (xf86ModeWidth(mode, output->initial_rotation) > width ||
+            xf86ModeHeight(mode, output->initial_rotation) > height)
+            continue;
+
+        /* exact matches are preferred */
+        if (output->initial_rotation == match_rotation &&
+            xf86ModesEqual(mode, match))
+            return mode;
+
+        dx = xf86ModeWidth(match, match_rotation) - xf86ModeWidth(mode,
+                                                                  output->
+                                                                  initial_rotation);
+        dy = xf86ModeHeight(match, match_rotation) - xf86ModeHeight(mode,
+                                                                    output->
+                                                                    initial_rotation);
+        diff = dx * dx + dy * dy;
+        if (target_mode == NULL || diff < target_diff) {
+            target_mode = mode;
+            target_diff = diff;
+        }
     }
     return target_mode;
 }
 
 static DisplayModePtr
-xf86OutputHasPreferredMode (xf86OutputPtr output, int width, int height)
+xf86OutputHasPreferredMode(xf86OutputPtr output, int width, int height)
 {
-    DisplayModePtr  mode;
+    DisplayModePtr mode;
 
-    for (mode = output->probed_modes; mode; mode = mode->next)
-    {
-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
-	    xf86ModeHeight (mode, output->initial_rotation) > height)
-	    continue;
+    for (mode = output->probed_modes; mode; mode = mode->next) {
+        if (xf86ModeWidth(mode, output->initial_rotation) > width ||
+            xf86ModeHeight(mode, output->initial_rotation) > height)
+            continue;
 
-	if (mode->type & M_T_PREFERRED)
-	    return mode;
+        if (mode->type & M_T_PREFERRED)
+            return mode;
     }
     return NULL;
 }
 
 static DisplayModePtr
-xf86OutputHasUserPreferredMode (xf86OutputPtr output)
+xf86OutputHasUserPreferredMode(xf86OutputPtr output)
 {
     DisplayModePtr mode, first = output->probed_modes;
 
     for (mode = first; mode && mode->next != first; mode = mode->next)
-	if (mode->type & M_T_USERPREF)
-	    return mode;
+        if (mode->type & M_T_USERPREF)
+            return mode;
 
     return NULL;
 }
 
 static int
-xf86PickCrtcs (ScrnInfoPtr	scrn,
-	       xf86CrtcPtr	*best_crtcs,
-	       DisplayModePtr	*modes,
-	       int		n,
-	       int		width,
-	       int		height)
-{
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int		    c, o;
-    xf86OutputPtr   output;
-    xf86CrtcPtr	    crtc;
-    xf86CrtcPtr	    *crtcs;
-    xf86CrtcPtr	    best_crtc;
-    int		    best_score;
-    int		    score;
-    int		    my_score;
-    
+xf86PickCrtcs(ScrnInfoPtr scrn,
+              xf86CrtcPtr * best_crtcs,
+              DisplayModePtr * modes, int n, int width, int height)
+{
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c, o;
+    xf86OutputPtr output;
+    xf86CrtcPtr crtc;
+    xf86CrtcPtr *crtcs;
+    xf86CrtcPtr best_crtc;
+    int best_score;
+    int score;
+    int my_score;
+
     if (n == config->num_output)
-	return 0;
+        return 0;
     output = config->output[n];
-    
+
     /*
      * Compute score with this output disabled
      */
     best_crtcs[n] = NULL;
     best_crtc = NULL;
-    best_score = xf86PickCrtcs (scrn, best_crtcs, modes, n+1, width, height);
+    best_score = xf86PickCrtcs(scrn, best_crtcs, modes, n + 1, width, height);
     if (modes[n] == NULL)
-	return best_score;
-    
-    crtcs = malloc(config->num_output * sizeof (xf86CrtcPtr));
+        return best_score;
+
+    crtcs = malloc(config->num_output * sizeof(xf86CrtcPtr));
     if (!crtcs)
-	return best_score;
+        return best_score;
 
     my_score = 1;
     /* Score outputs that are known to be connected higher */
     if (output->status == XF86OutputStatusConnected)
-	my_score++;
+        my_score++;
     /* Score outputs with preferred modes higher */
-    if (xf86OutputHasPreferredMode (output, width, height))
-	my_score++;
+    if (xf86OutputHasPreferredMode(output, width, height))
+        my_score++;
     /*
      * Select a crtc for this output and
      * then attempt to configure the remaining
      * outputs
      */
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	if ((output->possible_crtcs & (1 << c)) == 0)
-	    continue;
-	
-	crtc = config->crtc[c];
-	/*
-	 * Check to see if some other output is
-	 * using this crtc
-	 */
-	for (o = 0; o < n; o++)
-	    if (best_crtcs[o] == crtc)
-		break;
-	if (o < n)
-	{
-	    /*
-	     * If the two outputs desire the same mode,
-	     * see if they can be cloned
-	     */
-	    if (xf86ModesEqual (modes[o], modes[n]) &&
-		config->output[o]->initial_rotation == config->output[n]->initial_rotation &&
-		config->output[o]->initial_x == config->output[n]->initial_x &&
-		config->output[o]->initial_y == config->output[n]->initial_y)
-	    {
-		if ((output->possible_clones & (1 << o)) == 0)
-		    continue;		/* nope, try next CRTC */
-	    }
-	    else
-		continue;		/* different modes, can't clone */
-	}
-	crtcs[n] = crtc;
-	memcpy (crtcs, best_crtcs, n * sizeof (xf86CrtcPtr));
-	score = my_score + xf86PickCrtcs (scrn, crtcs, modes, n+1, width, height);
-	if (score > best_score)
-	{
-	    best_crtc = crtc;
-	    best_score = score;
-	    memcpy (best_crtcs, crtcs, config->num_output * sizeof (xf86CrtcPtr));
-	}
+    for (c = 0; c < config->num_crtc; c++) {
+        if ((output->possible_crtcs & (1 << c)) == 0)
+            continue;
+
+        crtc = config->crtc[c];
+        /*
+         * Check to see if some other output is
+         * using this crtc
+         */
+        for (o = 0; o < n; o++)
+            if (best_crtcs[o] == crtc)
+                break;
+        if (o < n) {
+            /*
+             * If the two outputs desire the same mode,
+             * see if they can be cloned
+             */
+            if (xf86ModesEqual(modes[o], modes[n]) &&
+                config->output[o]->initial_rotation ==
+                config->output[n]->initial_rotation &&
+                config->output[o]->initial_x == config->output[n]->initial_x &&
+                config->output[o]->initial_y == config->output[n]->initial_y) {
+                if ((output->possible_clones & (1 << o)) == 0)
+                    continue;   /* nope, try next CRTC */
+            }
+            else
+                continue;       /* different modes, can't clone */
+        }
+        crtcs[n] = crtc;
+        memcpy(crtcs, best_crtcs, n * sizeof(xf86CrtcPtr));
+        score =
+            my_score + xf86PickCrtcs(scrn, crtcs, modes, n + 1, width, height);
+        if (score > best_score) {
+            best_crtc = crtc;
+            best_score = score;
+            memcpy(best_crtcs, crtcs, config->num_output * sizeof(xf86CrtcPtr));
+        }
     }
     free(crtcs);
     return best_score;
 }
 
-
 /*
  * Compute the virtual size necessary to place all of the available
  * crtcs in the specified configuration.
@@ -1031,57 +1000,62 @@ xf86PickCrtcs (ScrnInfoPtr	scrn,
  */
 
 static void
-xf86DefaultScreenLimits (ScrnInfoPtr scrn, int *widthp, int *heightp,
-			 Bool canGrow)
-{
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int	    width = 0, height = 0;
-    int	    o;
-    int	    c;
-    int	    s;
-
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	int	    crtc_width = 0, crtc_height = 0;
-	xf86CrtcPtr crtc = config->crtc[c];
-
-	if (crtc->enabled)
-	{
-	    crtc_width = crtc->desiredX + xf86ModeWidth (&crtc->desiredMode, crtc->desiredRotation);
-	    crtc_height = crtc->desiredY + xf86ModeHeight (&crtc->desiredMode, crtc->desiredRotation);
-	}
-	if (!canGrow) {
-	    for (o = 0; o < config->num_output; o++)
-	    {
-		xf86OutputPtr   output = config->output[o];
-
-		for (s = 0; s < config->num_crtc; s++)
-		    if (output->possible_crtcs & (1 << s))
-		    {
-			DisplayModePtr  mode;
-			for (mode = output->probed_modes; mode; mode = mode->next)
-			{
-			    if (mode->HDisplay > crtc_width)
-				crtc_width = mode->HDisplay;
-			    if (mode->VDisplay > crtc_width)
-				crtc_width = mode->VDisplay;
-			    if (mode->VDisplay > crtc_height)
-				crtc_height = mode->VDisplay;
-			    if (mode->HDisplay > crtc_height)
-				crtc_height = mode->HDisplay;
-			}
-		    }
-	    }
-	}
-	if (crtc_width > width)
-	    width = crtc_width;
-	if (crtc_height > height)
-	    height = crtc_height;
-    }
-    if (config->maxWidth && width > config->maxWidth) width = config->maxWidth;
-    if (config->maxHeight && height > config->maxHeight) height = config->maxHeight;
-    if (config->minWidth && width < config->minWidth) width = config->minWidth;
-    if (config->minHeight && height < config->minHeight) height = config->minHeight;
+xf86DefaultScreenLimits(ScrnInfoPtr scrn, int *widthp, int *heightp,
+                        Bool canGrow)
+{
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int width = 0, height = 0;
+    int o;
+    int c;
+    int s;
+
+    for (c = 0; c < config->num_crtc; c++) {
+        int crtc_width = 0, crtc_height = 0;
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        if (crtc->enabled) {
+            crtc_width =
+                crtc->desiredX + xf86ModeWidth(&crtc->desiredMode,
+                                               crtc->desiredRotation);
+            crtc_height =
+                crtc->desiredY + xf86ModeHeight(&crtc->desiredMode,
+                                                crtc->desiredRotation);
+        }
+        if (!canGrow) {
+            for (o = 0; o < config->num_output; o++) {
+                xf86OutputPtr output = config->output[o];
+
+                for (s = 0; s < config->num_crtc; s++)
+                    if (output->possible_crtcs & (1 << s)) {
+                        DisplayModePtr mode;
+
+                        for (mode = output->probed_modes; mode;
+                             mode = mode->next) {
+                            if (mode->HDisplay > crtc_width)
+                                crtc_width = mode->HDisplay;
+                            if (mode->VDisplay > crtc_width)
+                                crtc_width = mode->VDisplay;
+                            if (mode->VDisplay > crtc_height)
+                                crtc_height = mode->VDisplay;
+                            if (mode->HDisplay > crtc_height)
+                                crtc_height = mode->HDisplay;
+                        }
+                    }
+            }
+        }
+        if (crtc_width > width)
+            width = crtc_width;
+        if (crtc_height > height)
+            height = crtc_height;
+    }
+    if (config->maxWidth && width > config->maxWidth)
+        width = config->maxWidth;
+    if (config->maxHeight && height > config->maxHeight)
+        height = config->maxHeight;
+    if (config->minWidth && width < config->minWidth)
+        width = config->minWidth;
+    if (config->minHeight && height < config->minHeight)
+        height = config->minHeight;
     *widthp = width;
     *heightp = height;
 }
@@ -1093,216 +1067,200 @@ xf86DefaultScreenLimits (ScrnInfoPtr scrn, int *widthp, int *heightp,
  * with either a position or a relative setting or a mode.
  */
 static Bool
-xf86UserConfiguredOutputs(ScrnInfoPtr scrn, DisplayModePtr *modes)
+xf86UserConfiguredOutputs(ScrnInfoPtr scrn, DisplayModePtr * modes)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
     int o;
     Bool user_conf = FALSE;
 
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr output = config->output[o];
-	char	    *position;
-	char	    *relative_name;
-	OutputOpts	    relation;
-	int r;
-	static const OutputOpts	relations[] = {
-	    OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
-	};
-
-	position = xf86GetOptValString (output->options,
-					OPTION_POSITION);
-	if (position)
-	    user_conf = TRUE;
-
-	relation = 0;
-	relative_name = NULL;
-	for (r = 0; r < 4; r++)
-	{
-	    relation = relations[r];
-	    relative_name = xf86GetOptValString (output->options,
-						     relation);
-	    if (relative_name)
-		break;
-	}
-	if (relative_name)
-	    user_conf = TRUE;
-
-	modes[o] = xf86OutputHasUserPreferredMode(output);
-	if (modes[o])
-	    user_conf = TRUE;
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        char *position;
+        char *relative_name;
+        OutputOpts relation;
+        int r;
+
+        static const OutputOpts relations[] = {
+            OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
+        };
+
+        position = xf86GetOptValString(output->options, OPTION_POSITION);
+        if (position)
+            user_conf = TRUE;
+
+        relation = 0;
+        relative_name = NULL;
+        for (r = 0; r < 4; r++) {
+            relation = relations[r];
+            relative_name = xf86GetOptValString(output->options, relation);
+            if (relative_name)
+                break;
+        }
+        if (relative_name)
+            user_conf = TRUE;
+
+        modes[o] = xf86OutputHasUserPreferredMode(output);
+        if (modes[o])
+            user_conf = TRUE;
     }
 
     return user_conf;
 }
 
 static Bool
-xf86InitialOutputPositions (ScrnInfoPtr scrn, DisplayModePtr *modes)
+xf86InitialOutputPositions(ScrnInfoPtr scrn, DisplayModePtr * modes)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o;
-    int			min_x, min_y;
-    
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
+    int min_x, min_y;
+
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
 
-	output->initial_x = output->initial_y = POSITION_UNSET;
+        output->initial_x = output->initial_y = POSITION_UNSET;
     }
-    
+
     /*
      * Loop until all outputs are set
      */
-    for (;;)
-    {
-	Bool	any_set = FALSE;
-	Bool	keep_going = FALSE;
-
-	for (o = 0; o < config->num_output; o++)	
-	{
-	    static const OutputOpts	relations[] = {
-		OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
-	    };
-	    xf86OutputPtr   output = config->output[o];
-	    xf86OutputPtr   relative;
-	    char	    *relative_name;
-	    char	    *position;
-	    OutputOpts	    relation;
-	    int		    r;
-
-	    if (output->initial_x != POSITION_UNSET)
-		continue;
-	    position = xf86GetOptValString (output->options,
-					    OPTION_POSITION);
-	    /*
-	     * Absolute position wins
-	     */
-	    if (position)
-	    {
-		int		    x, y;
-		if (sscanf (position, "%d %d", &x, &y) == 2)
-		{
-		    output->initial_x = x;
-		    output->initial_y = y;
-		}
-		else
-		{
-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-				"Output %s position not of form \"x y\"\n",
-				output->name);
-		    output->initial_x = output->initial_y = 0;
-		}
-		any_set = TRUE;
-		continue;
-	    }
-	    /*
-	     * Next comes relative positions
-	     */
-	    relation = 0;
-	    relative_name = NULL;
-	    for (r = 0; r < 4; r++)
-	    {
-		relation = relations[r];
-		relative_name = xf86GetOptValString (output->options,
-						     relation);
-		if (relative_name)
-		    break;
-	    }
-	    if (relative_name)
-	    {
-		int or;
-		relative = NULL;
-		for (or = 0; or < config->num_output; or++)
-		{
-		    xf86OutputPtr	out_rel = config->output[or];
-		    XF86ConfMonitorPtr	rel_mon = out_rel->conf_monitor;
-
-		    if (rel_mon)
-		    {
-			if (xf86nameCompare (rel_mon->mon_identifier,
-					      relative_name) == 0)
-			{
-			    relative = config->output[or];
-			    break;
-			}
-		    }
-		    if (strcmp (out_rel->name, relative_name) == 0)
-		    {
-			relative = config->output[or];
-			break;
-		    }
-		}
-		if (!relative)
-		{
-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-				"Cannot position output %s relative to unknown output %s\n",
-				output->name, relative_name);
-		    output->initial_x = 0;
-		    output->initial_y = 0;
-		    any_set = TRUE;
-		    continue;
-		}
-		if (!modes[or])
-		{
-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-				"Cannot position output %s relative to output %s without modes\n",
-				output->name, relative_name);
-		    output->initial_x = 0;
-		    output->initial_y = 0;
-		    any_set = TRUE;
-		    continue;
-		}
-		if (relative->initial_x == POSITION_UNSET)
-		{
-		    keep_going = TRUE;
-		    continue;
-		}
-		output->initial_x = relative->initial_x;
-		output->initial_y = relative->initial_y;
-		switch (relation) {
-		case OPTION_BELOW:
-		    output->initial_y += xf86ModeHeight (modes[or], relative->initial_rotation);
-		    break;
-		case OPTION_RIGHT_OF:
-		    output->initial_x += xf86ModeWidth (modes[or], relative->initial_rotation);
-		    break;
-		case OPTION_ABOVE:
-		    if (modes[o])
-			output->initial_y -= xf86ModeHeight (modes[o], output->initial_rotation);
-		    break;
-		case OPTION_LEFT_OF:
-		    if (modes[o])
-			output->initial_x -= xf86ModeWidth (modes[o], output->initial_rotation);
-		    break;
-		default:
-		    break;
-		}
-		any_set = TRUE;
-		continue;
-	    }
-	    
-	    /* Nothing set, just stick them at 0,0 */
-	    output->initial_x = 0;
-	    output->initial_y = 0;
-	    any_set = TRUE;
-	}
-	if (!keep_going)
-	    break;
-	if (!any_set) 
-	{
-	    for (o = 0; o < config->num_output; o++)
-	    {
-		xf86OutputPtr   output = config->output[o];
-		if (output->initial_x == POSITION_UNSET)
-		{
-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-				"Output position loop. Moving %s to 0,0\n",
-				output->name);
-		    output->initial_x = output->initial_y = 0;
-		    break;
-		}
-	    }
-	}
+    for (;;) {
+        Bool any_set = FALSE;
+        Bool keep_going = FALSE;
+
+        for (o = 0; o < config->num_output; o++) {
+            static const OutputOpts relations[] = {
+                OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
+            };
+            xf86OutputPtr output = config->output[o];
+            xf86OutputPtr relative;
+            char *relative_name;
+            char *position;
+            OutputOpts relation;
+            int r;
+
+            if (output->initial_x != POSITION_UNSET)
+                continue;
+            position = xf86GetOptValString(output->options, OPTION_POSITION);
+            /*
+             * Absolute position wins
+             */
+            if (position) {
+                int x, y;
+
+                if (sscanf(position, "%d %d", &x, &y) == 2) {
+                    output->initial_x = x;
+                    output->initial_y = y;
+                }
+                else {
+                    xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                               "Output %s position not of form \"x y\"\n",
+                               output->name);
+                    output->initial_x = output->initial_y = 0;
+                }
+                any_set = TRUE;
+                continue;
+            }
+            /*
+             * Next comes relative positions
+             */
+            relation = 0;
+            relative_name = NULL;
+            for (r = 0; r < 4; r++) {
+                relation = relations[r];
+                relative_name = xf86GetOptValString(output->options, relation);
+                if (relative_name)
+                    break;
+            }
+            if (relative_name) {
+                int or;
+
+                relative = NULL;
+                for (or = 0; or < config->num_output; or++) {
+                    xf86OutputPtr out_rel = config->output[or];
+                    XF86ConfMonitorPtr rel_mon = out_rel->conf_monitor;
+
+                    if (rel_mon) {
+                        if (xf86nameCompare(rel_mon->mon_identifier,
+                                            relative_name) == 0) {
+                            relative = config->output[or];
+                            break;
+                        }
+                    }
+                    if (strcmp(out_rel->name, relative_name) == 0) {
+                        relative = config->output[or];
+                        break;
+                    }
+                }
+                if (!relative) {
+                    xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                               "Cannot position output %s relative to unknown output %s\n",
+                               output->name, relative_name);
+                    output->initial_x = 0;
+                    output->initial_y = 0;
+                    any_set = TRUE;
+                    continue;
+                }
+                if (!modes[or]) {
+                    xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                               "Cannot position output %s relative to output %s without modes\n",
+                               output->name, relative_name);
+                    output->initial_x = 0;
+                    output->initial_y = 0;
+                    any_set = TRUE;
+                    continue;
+                }
+                if (relative->initial_x == POSITION_UNSET) {
+                    keep_going = TRUE;
+                    continue;
+                }
+                output->initial_x = relative->initial_x;
+                output->initial_y = relative->initial_y;
+                switch (relation) {
+                case OPTION_BELOW:
+                    output->initial_y +=
+                        xf86ModeHeight(modes[or], relative->initial_rotation);
+                    break;
+                case OPTION_RIGHT_OF:
+                    output->initial_x +=
+                        xf86ModeWidth(modes[or], relative->initial_rotation);
+                    break;
+                case OPTION_ABOVE:
+                    if (modes[o])
+                        output->initial_y -=
+                            xf86ModeHeight(modes[o], output->initial_rotation);
+                    break;
+                case OPTION_LEFT_OF:
+                    if (modes[o])
+                        output->initial_x -=
+                            xf86ModeWidth(modes[o], output->initial_rotation);
+                    break;
+                default:
+                    break;
+                }
+                any_set = TRUE;
+                continue;
+            }
+
+            /* Nothing set, just stick them at 0,0 */
+            output->initial_x = 0;
+            output->initial_y = 0;
+            any_set = TRUE;
+        }
+        if (!keep_going)
+            break;
+        if (!any_set) {
+            for (o = 0; o < config->num_output; o++) {
+                xf86OutputPtr output = config->output[o];
+
+                if (output->initial_x == POSITION_UNSET) {
+                    xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                               "Output position loop. Moving %s to 0,0\n",
+                               output->name);
+                    output->initial_x = output->initial_y = 0;
+                    break;
+                }
+            }
+        }
     }
 
     /*
@@ -1310,92 +1268,89 @@ xf86InitialOutputPositions (ScrnInfoPtr scrn, DisplayModePtr *modes)
      */
     min_x = 1000000;
     min_y = 1000000;
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
 
-	if (output->initial_x < min_x)
-	    min_x = output->initial_x;
-	if (output->initial_y < min_y)
-	    min_y = output->initial_y;
+        if (output->initial_x < min_x)
+            min_x = output->initial_x;
+        if (output->initial_y < min_y)
+            min_y = output->initial_y;
     }
-    
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
 
-	output->initial_x -= min_x;
-	output->initial_y -= min_y;
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+
+        output->initial_x -= min_x;
+        output->initial_y -= min_y;
     }
     return TRUE;
 }
 
 static void
-xf86InitialPanning (ScrnInfoPtr scrn)
+xf86InitialPanning(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o;
-    
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
-	char	       *panning = xf86GetOptValString (output->options, OPTION_PANNING);
-	int		width, height, left, top;
-	int		track_width, track_height, track_left, track_top;
-	int		brdr[4];
-
-	memset (&output->initialTotalArea,    0, sizeof(BoxRec));
-	memset (&output->initialTrackingArea, 0, sizeof(BoxRec));
-	memset (output->initialBorder,        0, 4*sizeof(INT16));
-
-	if (! panning)
-	    continue;
-
-	switch (sscanf (panning, "%dx%d+%d+%d/%dx%d+%d+%d/%d/%d/%d/%d",
-			&width, &height, &left, &top,
-			&track_width, &track_height, &track_left, &track_top,
-			&brdr[0], &brdr[1], &brdr[2], &brdr[3])) {
-	case 12:
-	    output->initialBorder[0] = brdr[0];
-	    output->initialBorder[1] = brdr[1];
-	    output->initialBorder[2] = brdr[2];
-	    output->initialBorder[3] = brdr[3];
-	    /* fall through */
-	case 8:
-	    output->initialTrackingArea.x1 = track_left;
-	    output->initialTrackingArea.y1 = track_top;
-	    output->initialTrackingArea.x2 = track_left + track_width;
-	    output->initialTrackingArea.y2 = track_top  + track_height;
-	    /* fall through */
-	case 4:
-	    output->initialTotalArea.x1 = left;
-	    output->initialTotalArea.y1 = top;
-	    /* fall through */
-	case 2:
-	    output->initialTotalArea.x2 = output->initialTotalArea.x1 + width;
-	    output->initialTotalArea.y2 = output->initialTotalArea.y1 + height;
-	    break;
-	default:
-	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-			"Broken panning specification '%s' for output %s in config file\n",
-			panning, output->name);
-	}
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
+
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        char *panning = xf86GetOptValString(output->options, OPTION_PANNING);
+        int width, height, left, top;
+        int track_width, track_height, track_left, track_top;
+        int brdr[4];
+
+        memset(&output->initialTotalArea, 0, sizeof(BoxRec));
+        memset(&output->initialTrackingArea, 0, sizeof(BoxRec));
+        memset(output->initialBorder, 0, 4 * sizeof(INT16));
+
+        if (!panning)
+            continue;
+
+        switch (sscanf(panning, "%dx%d+%d+%d/%dx%d+%d+%d/%d/%d/%d/%d",
+                       &width, &height, &left, &top,
+                       &track_width, &track_height, &track_left, &track_top,
+                       &brdr[0], &brdr[1], &brdr[2], &brdr[3])) {
+        case 12:
+            output->initialBorder[0] = brdr[0];
+            output->initialBorder[1] = brdr[1];
+            output->initialBorder[2] = brdr[2];
+            output->initialBorder[3] = brdr[3];
+            /* fall through */
+        case 8:
+            output->initialTrackingArea.x1 = track_left;
+            output->initialTrackingArea.y1 = track_top;
+            output->initialTrackingArea.x2 = track_left + track_width;
+            output->initialTrackingArea.y2 = track_top + track_height;
+            /* fall through */
+        case 4:
+            output->initialTotalArea.x1 = left;
+            output->initialTotalArea.y1 = top;
+            /* fall through */
+        case 2:
+            output->initialTotalArea.x2 = output->initialTotalArea.x1 + width;
+            output->initialTotalArea.y2 = output->initialTotalArea.y1 + height;
+            break;
+        default:
+            xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                       "Broken panning specification '%s' for output %s in config file\n",
+                       panning, output->name);
+        }
     }
 }
 
 /** Return - 0 + if a should be earlier, same or later than b in list
  */
 static int
-xf86ModeCompare (DisplayModePtr a, DisplayModePtr b)
+xf86ModeCompare(DisplayModePtr a, DisplayModePtr b)
 {
-    int	diff;
+    int diff;
 
     diff = ((b->type & M_T_PREFERRED) != 0) - ((a->type & M_T_PREFERRED) != 0);
     if (diff)
-	return diff;
+        return diff;
     diff = b->HDisplay * b->VDisplay - a->HDisplay * a->VDisplay;
     if (diff)
-	return diff;
+        return diff;
     diff = b->Clock - a->Clock;
     return diff;
 }
@@ -1404,38 +1359,34 @@ xf86ModeCompare (DisplayModePtr a, DisplayModePtr b)
  * Insertion sort input in-place and return the resulting head
  */
 static DisplayModePtr
-xf86SortModes (DisplayModePtr input)
+xf86SortModes(DisplayModePtr input)
 {
-    DisplayModePtr  output = NULL, i, o, n, *op, prev;
+    DisplayModePtr output = NULL, i, o, n, *op, prev;
 
     /* sort by preferred status and pixel area */
-    while (input)
-    {
-	i = input;
-	input = input->next;
-	for (op = &output; (o = *op); op = &o->next)
-	    if (xf86ModeCompare (o, i) > 0)
-		break;
-	i->next = *op;
-	*op = i;
+    while (input) {
+        i = input;
+        input = input->next;
+        for (op = &output; (o = *op); op = &o->next)
+            if (xf86ModeCompare(o, i) > 0)
+                break;
+        i->next = *op;
+        *op = i;
     }
     /* prune identical modes */
-    for (o = output; o && (n = o->next); o = n)
-    {
-	if (!strcmp (o->name, n->name) && xf86ModesEqual (o, n))
-	{
-	    o->next = n->next;
-	    free(n->name);
-	    free(n);
-	    n = o;
-	}
+    for (o = output; o && (n = o->next); o = n) {
+        if (!strcmp(o->name, n->name) && xf86ModesEqual(o, n)) {
+            o->next = n->next;
+            free(n->name);
+            free(n);
+            n = o;
+        }
     }
     /* hook up backward links */
     prev = NULL;
-    for (o = output; o; o = o->next)
-    {
-	o->prev = prev;
-	prev = o;
+    for (o = output; o; o = o->next) {
+        o->prev = prev;
+        prev = o;
     }
     return output;
 }
@@ -1446,13 +1397,13 @@ preferredMode(ScrnInfoPtr pScrn, xf86OutputPtr output)
     char *preferred_mode = NULL;
 
     /* Check for a configured preference for a particular mode */
-    preferred_mode = xf86GetOptValString (output->options,
-					  OPTION_PREFERRED_MODE);
+    preferred_mode = xf86GetOptValString(output->options,
+                                         OPTION_PREFERRED_MODE);
     if (preferred_mode)
-	return preferred_mode;
+        return preferred_mode;
 
     if (pScrn->display->modes && *pScrn->display->modes)
-	preferred_mode = *pScrn->display->modes;
+        preferred_mode = *pScrn->display->modes;
 
     return preferred_mode;
 }
@@ -1461,7 +1412,7 @@ static void
 GuessRangeFromModes(MonPtr mon, DisplayModePtr mode)
 {
     if (!mon || !mode)
-       return;
+        return;
 
     mon->nHsync = 1;
     mon->hsync[0].lo = 1024.0;
@@ -1472,33 +1423,33 @@ GuessRangeFromModes(MonPtr mon, DisplayModePtr mode)
     mon->vrefresh[0].hi = 0.0;
 
     while (mode) {
-	if (!mode->HSync)
-	    mode->HSync = ((float) mode->Clock ) / ((float) mode->HTotal);
+        if (!mode->HSync)
+            mode->HSync = ((float) mode->Clock) / ((float) mode->HTotal);
 
-	if (!mode->VRefresh)
-	    mode->VRefresh = (1000.0 * ((float) mode->Clock)) / 
-		((float) (mode->HTotal * mode->VTotal));
+        if (!mode->VRefresh)
+            mode->VRefresh = (1000.0 * ((float) mode->Clock)) /
+                ((float) (mode->HTotal * mode->VTotal));
 
-	if (mode->HSync < mon->hsync[0].lo)
-	    mon->hsync[0].lo = mode->HSync;
+        if (mode->HSync < mon->hsync[0].lo)
+            mon->hsync[0].lo = mode->HSync;
 
-	if (mode->HSync > mon->hsync[0].hi)
-	    mon->hsync[0].hi = mode->HSync;
+        if (mode->HSync > mon->hsync[0].hi)
+            mon->hsync[0].hi = mode->HSync;
 
-	if (mode->VRefresh < mon->vrefresh[0].lo)
-	    mon->vrefresh[0].lo = mode->VRefresh;
+        if (mode->VRefresh < mon->vrefresh[0].lo)
+            mon->vrefresh[0].lo = mode->VRefresh;
 
-	if (mode->VRefresh > mon->vrefresh[0].hi)
-	    mon->vrefresh[0].hi = mode->VRefresh;
+        if (mode->VRefresh > mon->vrefresh[0].hi)
+            mon->vrefresh[0].hi = mode->VRefresh;
 
-	mode = mode->next;
+        mode = mode->next;
     }
 
     /* stretch out the bottom to fit 640x480@60 */
     if (mon->hsync[0].lo > 31.0)
-       mon->hsync[0].lo = 31.0;
+        mon->hsync[0].lo = 31.0;
     if (mon->vrefresh[0].lo > 58.0)
-       mon->vrefresh[0].lo = 58.0;
+        mon->vrefresh[0].lo = 58.0;
 }
 
 enum det_monrec_source {
@@ -1513,14 +1464,16 @@ struct det_monrec_parameter {
     enum det_monrec_source *sync_source;
 };
 
-static void handle_detailed_monrec(struct detailed_monitor_section *det_mon,
-                                   void *data)
+static void
+handle_detailed_monrec(struct detailed_monitor_section *det_mon, void *data)
 {
     struct det_monrec_parameter *p;
-    p = (struct det_monrec_parameter *)data;
+
+    p = (struct det_monrec_parameter *) data;
 
     if (det_mon->type == DS_RANGES) {
         struct monitor_ranges *ranges = &det_mon->section.ranges;
+
         if (p->set_hsync && ranges->max_h) {
             p->mon_rec->hsync[p->mon_rec->nHsync].lo = ranges->min_h;
             p->mon_rec->hsync[p->mon_rec->nHsync].hi = ranges->max_h;
@@ -1541,10 +1494,10 @@ static void handle_detailed_monrec(struct detailed_monitor_section *det_mon,
 }
 
 void
-xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)
+xf86ProbeOutputModes(ScrnInfoPtr scrn, int maxX, int maxY)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
 
     /* When canGrow was TRUE in the initial configuration we have to
      * compare against the maximum values so that we don't drop modes.
@@ -1552,251 +1505,238 @@ xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)
      * anyway.
      */
     if (maxX == 0 || maxY == 0) {
-	maxX = config->maxWidth;
-	maxY = config->maxHeight;
+        maxX = config->maxWidth;
+        maxY = config->maxHeight;
     }
 
     /* Probe the list of modes for each output. */
-    for (o = 0; o < config->num_output; o++) 
-    {
-	xf86OutputPtr	    output = config->output[o];
-	DisplayModePtr	    mode;
-	DisplayModePtr	    config_modes = NULL, output_modes, default_modes = NULL;
-	char		    *preferred_mode;
-	xf86MonPtr	    edid_monitor;
-	XF86ConfMonitorPtr  conf_monitor;
-	MonRec		    mon_rec;
-	int		    min_clock = 0;
-	int		    max_clock = 0;
-	double		    clock;
-	Bool		    add_default_modes;
-	Bool		    debug_modes = config->debug_modes ||
-					  xf86Initialising;
-	enum det_monrec_source sync_source = sync_default;
-	
-	while (output->probed_modes != NULL)
-	    xf86DeleteMode(&output->probed_modes, output->probed_modes);
-
-	/*
-	 * Check connection status
-	 */
-	output->status = (*output->funcs->detect)(output);
-
-	if (output->status == XF86OutputStatusDisconnected &&
-		!xf86ReturnOptValBool(output->options, OPTION_ENABLE, FALSE))
-	{
-	    xf86OutputSetEDID (output, NULL);
-	    continue;
-	}
-
-	memset (&mon_rec, '\0', sizeof (mon_rec));
-	
-	conf_monitor = output->conf_monitor;
-	
-	if (conf_monitor)
-	{
-	    int	i;
-	    
-	    for (i = 0; i < conf_monitor->mon_n_hsync; i++)
-	    {
-		mon_rec.hsync[mon_rec.nHsync].lo = conf_monitor->mon_hsync[i].lo;
-		mon_rec.hsync[mon_rec.nHsync].hi = conf_monitor->mon_hsync[i].hi;
-		mon_rec.nHsync++;
-		sync_source = sync_config;
-	    }
-	    for (i = 0; i < conf_monitor->mon_n_vrefresh; i++)
-	    {
-		mon_rec.vrefresh[mon_rec.nVrefresh].lo = conf_monitor->mon_vrefresh[i].lo;
-		mon_rec.vrefresh[mon_rec.nVrefresh].hi = conf_monitor->mon_vrefresh[i].hi;
-		mon_rec.nVrefresh++;
-		sync_source = sync_config;
-	    }
-	    config_modes = xf86GetMonitorModes (scrn, conf_monitor);
-	}
-	
-	output_modes = (*output->funcs->get_modes) (output);
-
-	/*
-	 * If the user has a preference, respect it.
-	 * Otherwise, don't second-guess the driver.
-	 */
-	if (!xf86GetOptValBool(output->options, OPTION_DEFAULT_MODES,
-			       &add_default_modes))
-	    add_default_modes = (output_modes == NULL);
-	
-	edid_monitor = output->MonInfo;
-	
-        if (edid_monitor)
-        {
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        DisplayModePtr mode;
+        DisplayModePtr config_modes = NULL, output_modes, default_modes = NULL;
+        char *preferred_mode;
+        xf86MonPtr edid_monitor;
+        XF86ConfMonitorPtr conf_monitor;
+        MonRec mon_rec;
+        int min_clock = 0;
+        int max_clock = 0;
+        double clock;
+        Bool add_default_modes;
+        Bool debug_modes = config->debug_modes || xf86Initialising;
+        enum det_monrec_source sync_source = sync_default;
+
+        while (output->probed_modes != NULL)
+            xf86DeleteMode(&output->probed_modes, output->probed_modes);
+
+        /*
+         * Check connection status
+         */
+        output->status = (*output->funcs->detect) (output);
+
+        if (output->status == XF86OutputStatusDisconnected &&
+            !xf86ReturnOptValBool(output->options, OPTION_ENABLE, FALSE)) {
+            xf86OutputSetEDID(output, NULL);
+            continue;
+        }
+
+        memset(&mon_rec, '\0', sizeof(mon_rec));
+
+        conf_monitor = output->conf_monitor;
+
+        if (conf_monitor) {
+            int i;
+
+            for (i = 0; i < conf_monitor->mon_n_hsync; i++) {
+                mon_rec.hsync[mon_rec.nHsync].lo =
+                    conf_monitor->mon_hsync[i].lo;
+                mon_rec.hsync[mon_rec.nHsync].hi =
+                    conf_monitor->mon_hsync[i].hi;
+                mon_rec.nHsync++;
+                sync_source = sync_config;
+            }
+            for (i = 0; i < conf_monitor->mon_n_vrefresh; i++) {
+                mon_rec.vrefresh[mon_rec.nVrefresh].lo =
+                    conf_monitor->mon_vrefresh[i].lo;
+                mon_rec.vrefresh[mon_rec.nVrefresh].hi =
+                    conf_monitor->mon_vrefresh[i].hi;
+                mon_rec.nVrefresh++;
+                sync_source = sync_config;
+            }
+            config_modes = xf86GetMonitorModes(scrn, conf_monitor);
+        }
+
+        output_modes = (*output->funcs->get_modes) (output);
+
+        /*
+         * If the user has a preference, respect it.
+         * Otherwise, don't second-guess the driver.
+         */
+        if (!xf86GetOptValBool(output->options, OPTION_DEFAULT_MODES,
+                               &add_default_modes))
+            add_default_modes = (output_modes == NULL);
+
+        edid_monitor = output->MonInfo;
+
+        if (edid_monitor) {
             struct det_monrec_parameter p;
-            struct disp_features    *features = &edid_monitor->features;
-
-	    /* if display is not continuous-frequency, don't add default modes */
-	    if (!GTF_SUPPORTED(features->msc))
-		add_default_modes = FALSE;
-
-	    p.mon_rec = &mon_rec;
-	    p.max_clock = &max_clock;
-	    p.set_hsync = mon_rec.nHsync == 0;
-	    p.set_vrefresh = mon_rec.nVrefresh == 0;
-	    p.sync_source = &sync_source;
-
-	    xf86ForEachDetailedBlock(edid_monitor,
-			             handle_detailed_monrec,
-			             &p);
-	}
-
-	if (xf86GetOptValFreq (output->options, OPTION_MIN_CLOCK,
-			       OPTUNITS_KHZ, &clock))
-	    min_clock = (int) clock;
-	if (xf86GetOptValFreq (output->options, OPTION_MAX_CLOCK,
-			       OPTUNITS_KHZ, &clock))
-	    max_clock = (int) clock;
-
-	/* If we still don't have a sync range, guess wildly */
-	if (!mon_rec.nHsync || !mon_rec.nVrefresh)
-	    GuessRangeFromModes(&mon_rec, output_modes);
-
-	/*
-	 * These limits will end up setting a 1024x768@60Hz mode by default,
-	 * which seems like a fairly good mode to use when nothing else is
-	 * specified
-	 */
-	if (mon_rec.nHsync == 0)
-	{
-	    mon_rec.hsync[0].lo = 31.0;
-	    mon_rec.hsync[0].hi = 55.0;
-	    mon_rec.nHsync = 1;
-	}
-	if (mon_rec.nVrefresh == 0)
-	{
-	    mon_rec.vrefresh[0].lo = 58.0;
-	    mon_rec.vrefresh[0].hi = 62.0;
-	    mon_rec.nVrefresh = 1;
-	}
-
-	if (add_default_modes)
-	    default_modes = xf86GetDefaultModes ();
-
-	/*
-	 * If this is not an RB monitor, remove RB modes from the default
-	 * pool.  RB modes from the config or the monitor itself are fine.
-	 */
-	if (!mon_rec.reducedblanking)
-	    xf86ValidateModesReducedBlanking (scrn, default_modes);
-
-	if (sync_source == sync_config)
-	{
-	    /* 
-	     * Check output and config modes against sync range from config file
-	     */
-	    xf86ValidateModesSync (scrn, output_modes, &mon_rec);
-	    xf86ValidateModesSync (scrn, config_modes, &mon_rec);
-	}
-	/*
-	 * Check default modes against sync range
-	 */
-        xf86ValidateModesSync (scrn, default_modes, &mon_rec);
-	/*
-	 * Check default modes against monitor max clock
-	 */
-	if (max_clock) {
-	    xf86ValidateModesClocks(scrn, default_modes,
-				    &min_clock, &max_clock, 1);
-	    xf86ValidateModesClocks(scrn, output_modes,
-				    &min_clock, &max_clock, 1);
-	}
-	
-	output->probed_modes = NULL;
-	output->probed_modes = xf86ModesAdd (output->probed_modes, config_modes);
-	output->probed_modes = xf86ModesAdd (output->probed_modes, output_modes);
-	output->probed_modes = xf86ModesAdd (output->probed_modes, default_modes);
-	
-	/*
-	 * Check all modes against max size, interlace, and doublescan
-	 */
-	if (maxX && maxY)
-	    xf86ValidateModesSize (scrn, output->probed_modes,
-				       maxX, maxY, 0);
-
-	{
-	    int flags = (output->interlaceAllowed ? V_INTERLACE : 0) |
-			(output->doubleScanAllowed ? V_DBLSCAN : 0);
-	    xf86ValidateModesFlags (scrn, output->probed_modes, flags);
-	}
-	 
-	/*
-	 * Check all modes against output
-	 */
-	for (mode = output->probed_modes; mode != NULL; mode = mode->next) 
-	    if (mode->status == MODE_OK)
-		mode->status = (*output->funcs->mode_valid)(output, mode);
-	
-	xf86PruneInvalidModes(scrn, &output->probed_modes, debug_modes);
-	
-	output->probed_modes = xf86SortModes (output->probed_modes);
-	
-	/* Check for a configured preference for a particular mode */
-	preferred_mode = preferredMode(scrn, output);
-
-	if (preferred_mode)
-	{
-	    for (mode = output->probed_modes; mode; mode = mode->next)
-	    {
-		if (!strcmp (preferred_mode, mode->name))
-		{
-		    if (mode != output->probed_modes)
-		    {
-			if (mode->prev)
-			    mode->prev->next = mode->next;
-			if (mode->next)
-			    mode->next->prev = mode->prev;
-			mode->next = output->probed_modes;
-			output->probed_modes->prev = mode;
-			mode->prev = NULL;
-			output->probed_modes = mode;
-		    }
-		    mode->type |= (M_T_PREFERRED|M_T_USERPREF);
-		    break;
-		}
-	    }
-	}
-	
-	output->initial_rotation = xf86OutputInitialRotation (output);
-
-	if (debug_modes) {
-	    if (output->probed_modes != NULL) {
-		xf86DrvMsg(scrn->scrnIndex, X_INFO,
-			   "Printing probed modes for output %s\n",
-			   output->name);
-	    } else {
-		xf86DrvMsg(scrn->scrnIndex, X_INFO,
-			   "No remaining probed modes for output %s\n",
-			   output->name);
-	    }
-	}
-	for (mode = output->probed_modes; mode != NULL; mode = mode->next)
-	{
-	    /* The code to choose the best mode per pipe later on will require
-	     * VRefresh to be set.
-	     */
-	    mode->VRefresh = xf86ModeVRefresh(mode);
-	    xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
-
-	    if (debug_modes)
-		xf86PrintModeline(scrn->scrnIndex, mode);
-	}
+            struct disp_features *features = &edid_monitor->features;
+
+            /* if display is not continuous-frequency, don't add default modes */
+            if (!GTF_SUPPORTED(features->msc))
+                add_default_modes = FALSE;
+
+            p.mon_rec = &mon_rec;
+            p.max_clock = &max_clock;
+            p.set_hsync = mon_rec.nHsync == 0;
+            p.set_vrefresh = mon_rec.nVrefresh == 0;
+            p.sync_source = &sync_source;
+
+            xf86ForEachDetailedBlock(edid_monitor, handle_detailed_monrec, &p);
+        }
+
+        if (xf86GetOptValFreq(output->options, OPTION_MIN_CLOCK,
+                              OPTUNITS_KHZ, &clock))
+            min_clock = (int) clock;
+        if (xf86GetOptValFreq(output->options, OPTION_MAX_CLOCK,
+                              OPTUNITS_KHZ, &clock))
+            max_clock = (int) clock;
+
+        /* If we still don't have a sync range, guess wildly */
+        if (!mon_rec.nHsync || !mon_rec.nVrefresh)
+            GuessRangeFromModes(&mon_rec, output_modes);
+
+        /*
+         * These limits will end up setting a 1024x768@60Hz mode by default,
+         * which seems like a fairly good mode to use when nothing else is
+         * specified
+         */
+        if (mon_rec.nHsync == 0) {
+            mon_rec.hsync[0].lo = 31.0;
+            mon_rec.hsync[0].hi = 55.0;
+            mon_rec.nHsync = 1;
+        }
+        if (mon_rec.nVrefresh == 0) {
+            mon_rec.vrefresh[0].lo = 58.0;
+            mon_rec.vrefresh[0].hi = 62.0;
+            mon_rec.nVrefresh = 1;
+        }
+
+        if (add_default_modes)
+            default_modes = xf86GetDefaultModes();
+
+        /*
+         * If this is not an RB monitor, remove RB modes from the default
+         * pool.  RB modes from the config or the monitor itself are fine.
+         */
+        if (!mon_rec.reducedblanking)
+            xf86ValidateModesReducedBlanking(scrn, default_modes);
+
+        if (sync_source == sync_config) {
+            /* 
+             * Check output and config modes against sync range from config file
+             */
+            xf86ValidateModesSync(scrn, output_modes, &mon_rec);
+            xf86ValidateModesSync(scrn, config_modes, &mon_rec);
+        }
+        /*
+         * Check default modes against sync range
+         */
+        xf86ValidateModesSync(scrn, default_modes, &mon_rec);
+        /*
+         * Check default modes against monitor max clock
+         */
+        if (max_clock) {
+            xf86ValidateModesClocks(scrn, default_modes,
+                                    &min_clock, &max_clock, 1);
+            xf86ValidateModesClocks(scrn, output_modes,
+                                    &min_clock, &max_clock, 1);
+        }
+
+        output->probed_modes = NULL;
+        output->probed_modes = xf86ModesAdd(output->probed_modes, config_modes);
+        output->probed_modes = xf86ModesAdd(output->probed_modes, output_modes);
+        output->probed_modes =
+            xf86ModesAdd(output->probed_modes, default_modes);
+
+        /*
+         * Check all modes against max size, interlace, and doublescan
+         */
+        if (maxX && maxY)
+            xf86ValidateModesSize(scrn, output->probed_modes, maxX, maxY, 0);
+
+        {
+            int flags = (output->interlaceAllowed ? V_INTERLACE : 0) |
+                (output->doubleScanAllowed ? V_DBLSCAN : 0);
+            xf86ValidateModesFlags(scrn, output->probed_modes, flags);
+        }
+
+        /*
+         * Check all modes against output
+         */
+        for (mode = output->probed_modes; mode != NULL; mode = mode->next)
+            if (mode->status == MODE_OK)
+                mode->status = (*output->funcs->mode_valid) (output, mode);
+
+        xf86PruneInvalidModes(scrn, &output->probed_modes, debug_modes);
+
+        output->probed_modes = xf86SortModes(output->probed_modes);
+
+        /* Check for a configured preference for a particular mode */
+        preferred_mode = preferredMode(scrn, output);
+
+        if (preferred_mode) {
+            for (mode = output->probed_modes; mode; mode = mode->next) {
+                if (!strcmp(preferred_mode, mode->name)) {
+                    if (mode != output->probed_modes) {
+                        if (mode->prev)
+                            mode->prev->next = mode->next;
+                        if (mode->next)
+                            mode->next->prev = mode->prev;
+                        mode->next = output->probed_modes;
+                        output->probed_modes->prev = mode;
+                        mode->prev = NULL;
+                        output->probed_modes = mode;
+                    }
+                    mode->type |= (M_T_PREFERRED | M_T_USERPREF);
+                    break;
+                }
+            }
+        }
+
+        output->initial_rotation = xf86OutputInitialRotation(output);
+
+        if (debug_modes) {
+            if (output->probed_modes != NULL) {
+                xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                           "Printing probed modes for output %s\n",
+                           output->name);
+            }
+            else {
+                xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                           "No remaining probed modes for output %s\n",
+                           output->name);
+            }
+        }
+        for (mode = output->probed_modes; mode != NULL; mode = mode->next) {
+            /* The code to choose the best mode per pipe later on will require
+             * VRefresh to be set.
+             */
+            mode->VRefresh = xf86ModeVRefresh(mode);
+            xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
+
+            if (debug_modes)
+                xf86PrintModeline(scrn->scrnIndex, mode);
+        }
     }
 }
 
-
 /**
  * Copy one of the output mode lists to the ScrnInfo record
  */
 
 /* XXX where does this function belong? Here? */
 void
-xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr scrn, int *x, int *y);
+ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr scrn, int *x, int *y);
 
 static DisplayModePtr
 biggestMode(DisplayModePtr a, DisplayModePtr b)
@@ -1804,15 +1744,15 @@ biggestMode(DisplayModePtr a, DisplayModePtr b)
     int A, B;
 
     if (!a)
-	return b;
+        return b;
     if (!b)
-	return a;
+        return a;
 
     A = a->HDisplay * a->VDisplay;
     B = b->HDisplay * b->VDisplay;
 
     if (A > B)
-	return a;
+        return a;
 
     return b;
 }
@@ -1825,141 +1765,143 @@ SetCompatOutput(xf86CrtcConfigPtr config)
     int o, compat = -1, count, mincount = 0;
 
     /* Look for one that's definitely connected */
-    for (o = 0; o < config->num_output; o++)
-    {
-	test = config->output[o];
-	if (!test->crtc)
-	    continue;
-	if (test->status != XF86OutputStatusConnected)
-	    continue;
-	if (!test->probed_modes)
-	    continue;
-
-	testmode = mode = test->probed_modes;
-	for (count = 0; mode; mode = mode->next, count++)
-	    testmode = biggestMode(testmode, mode);
-
-	if (!output) {
-	    output = test;
-	    compat = o;
-	    maxmode = testmode;
-	    mincount = count;
-	} else if (maxmode == biggestMode(maxmode, testmode)) {
-	    output = test;
-	    compat = o;
-	    maxmode = testmode;
-	    mincount = count;
-	} else if ((maxmode->HDisplay == testmode->HDisplay) && 
-		(maxmode->VDisplay == testmode->VDisplay) &&
-		count <= mincount) {
-	    output = test;
-	    compat = o;
-	    maxmode = testmode;
-	    mincount = count;
-	}
+    for (o = 0; o < config->num_output; o++) {
+        test = config->output[o];
+        if (!test->crtc)
+            continue;
+        if (test->status != XF86OutputStatusConnected)
+            continue;
+        if (!test->probed_modes)
+            continue;
+
+        testmode = mode = test->probed_modes;
+        for (count = 0; mode; mode = mode->next, count++)
+            testmode = biggestMode(testmode, mode);
+
+        if (!output) {
+            output = test;
+            compat = o;
+            maxmode = testmode;
+            mincount = count;
+        }
+        else if (maxmode == biggestMode(maxmode, testmode)) {
+            output = test;
+            compat = o;
+            maxmode = testmode;
+            mincount = count;
+        }
+        else if ((maxmode->HDisplay == testmode->HDisplay) &&
+                 (maxmode->VDisplay == testmode->VDisplay) &&
+                 count <= mincount) {
+            output = test;
+            compat = o;
+            maxmode = testmode;
+            mincount = count;
+        }
     }
 
     /* If we didn't find one, take anything we can get */
-    if (!output)
-    {
-	for (o = 0; o < config->num_output; o++)
-	{
-	    test = config->output[o];
-	    if (!test->crtc)
-		continue;
-	    if (!test->probed_modes)
-		continue;
-
-	    if (!output) {
-		output = test;
-		compat = o;
-	    } else if (test->probed_modes->HDisplay < output->probed_modes->HDisplay) {
-		output = test;
-		compat = o;
-	    }
-	}
+    if (!output) {
+        for (o = 0; o < config->num_output; o++) {
+            test = config->output[o];
+            if (!test->crtc)
+                continue;
+            if (!test->probed_modes)
+                continue;
+
+            if (!output) {
+                output = test;
+                compat = o;
+            }
+            else if (test->probed_modes->HDisplay <
+                     output->probed_modes->HDisplay) {
+                output = test;
+                compat = o;
+            }
+        }
     }
 
     if (compat >= 0) {
-	config->compat_output = compat;
-    } else {
-	/* Don't change the compat output when no valid outputs found */
-	output = config->output[config->compat_output];
+        config->compat_output = compat;
+    }
+    else {
+        /* Don't change the compat output when no valid outputs found */
+        output = config->output[config->compat_output];
     }
 
     return output;
 }
 
 void
-xf86SetScrnInfoModes (ScrnInfoPtr scrn)
+xf86SetScrnInfoModes(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86OutputPtr	output;
-    xf86CrtcPtr		crtc;
-    DisplayModePtr	last, mode = NULL;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86OutputPtr output;
+    xf86CrtcPtr crtc;
+    DisplayModePtr last, mode = NULL;
 
     output = SetCompatOutput(config);
 
     if (!output)
-	return; /* punt */
+        return;                 /* punt */
 
     crtc = output->crtc;
 
     /* Clear any existing modes from scrn->modes */
     while (scrn->modes != NULL)
-	xf86DeleteMode(&scrn->modes, scrn->modes);
+        xf86DeleteMode(&scrn->modes, scrn->modes);
 
     /* Set scrn->modes to the mode list for the 'compat' output */
     scrn->modes = xf86DuplicateModes(scrn, output->probed_modes);
 
     if (crtc) {
-	for (mode = scrn->modes; mode; mode = mode->next)
-	    if (xf86ModesEqual (mode, &crtc->desiredMode))
-		break;
+        for (mode = scrn->modes; mode; mode = mode->next)
+            if (xf86ModesEqual(mode, &crtc->desiredMode))
+                break;
     }
 
     if (!scrn->modes) {
-	scrn->modes = xf86ModesAdd(scrn->modes,
-				   xf86CVTMode(scrn->display->virtualX,
-					       scrn->display->virtualY,
-					       60, 0, 0));
+        scrn->modes = xf86ModesAdd(scrn->modes,
+                                   xf86CVTMode(scrn->display->virtualX,
+                                               scrn->display->virtualY,
+                                               60, 0, 0));
     }
 
     /* For some reason, scrn->modes is circular, unlike the other mode
      * lists.  How great is that?
      */
-    for (last = scrn->modes; last && last->next; last = last->next)
-	;
+    for (last = scrn->modes; last && last->next; last = last->next);
     last->next = scrn->modes;
     scrn->modes->prev = last;
     if (mode) {
-	while (scrn->modes != mode)
-	    scrn->modes = scrn->modes->next;
+        while (scrn->modes != mode)
+            scrn->modes = scrn->modes->next;
     }
 
     scrn->currentMode = scrn->modes;
 #ifdef XFreeXDGA
     if (scrn->pScreen)
-	    _xf86_di_dga_reinit_internal(scrn->pScreen);
+        _xf86_di_dga_reinit_internal(scrn->pScreen);
 #endif
 }
 
 static Bool
 xf86CollectEnabledOutputs(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
-			  Bool *enabled)
+                          Bool *enabled)
 {
     Bool any_enabled = FALSE;
     int o;
 
     for (o = 0; o < config->num_output; o++)
-	any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], TRUE);
-    
+        any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], TRUE);
+
     if (!any_enabled) {
-	xf86DrvMsg(scrn->scrnIndex, X_WARNING,
-		   "No outputs definitely connected, trying again...\n");
+        xf86DrvMsg(scrn->scrnIndex, X_WARNING,
+                   "No outputs definitely connected, trying again...\n");
 
-	for (o = 0; o < config->num_output; o++)
-	    any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], FALSE);
+        for (o = 0; o < config->num_output; o++)
+            any_enabled |= enabled[o] =
+                xf86OutputEnabled(config->output[o], FALSE);
     }
 
     return any_enabled;
@@ -1971,12 +1913,12 @@ nextEnabledOutput(xf86CrtcConfigPtr config, Bool *enabled, int *index)
     int o = *index;
 
     for (o++; o < config->num_output; o++) {
-	if (enabled[o]) {
-	    *index = o;
-	    return TRUE;
-	}
+        if (enabled[o]) {
+            *index = o;
+            return TRUE;
+        }
     }
-    
+
     return FALSE;
 }
 
@@ -1992,16 +1934,16 @@ nextAspectMode(xf86OutputPtr o, DisplayModePtr last, float aspect)
     DisplayModePtr m = NULL;
 
     if (!o)
-	return NULL;
+        return NULL;
 
     if (!last)
-	m = o->probed_modes;
+        m = o->probed_modes;
     else
-	m = last->next;
+        m = last->next;
 
     for (; m; m = m->next)
-	if (aspectMatch(aspect, (float)m->HDisplay / (float)m->VDisplay))
-	    return m;
+        if (aspectMatch(aspect, (float) m->HDisplay / (float) m->VDisplay))
+            return m;
 
     return NULL;
 }
@@ -2013,27 +1955,27 @@ bestModeForAspect(xf86CrtcConfigPtr config, Bool *enabled, float aspect)
     DisplayModePtr mode = NULL, test = NULL, match = NULL;
 
     if (!nextEnabledOutput(config, enabled, &o))
-	return NULL;
+        return NULL;
     while ((mode = nextAspectMode(config->output[o], mode, aspect))) {
-	test = mode;
-	for (p = o; nextEnabledOutput(config, enabled, &p); ) {
-	    test = xf86OutputFindClosestMode(config->output[p], mode);
-	    if (!test)
-		break;
-	    if (test->HDisplay != mode->HDisplay ||
-		    test->VDisplay != mode->VDisplay) {
-		test = NULL;
-		break;
-	    }
-	}
-
-	/* if we didn't match it on all outputs, try the next one */
-	if (!test)
-	    continue;
-
-	/* if it's bigger than the last one, save it */
-	if (!match || (test->HDisplay > match->HDisplay))
-	    match = test;
+        test = mode;
+        for (p = o; nextEnabledOutput(config, enabled, &p);) {
+            test = xf86OutputFindClosestMode(config->output[p], mode);
+            if (!test)
+                break;
+            if (test->HDisplay != mode->HDisplay ||
+                test->VDisplay != mode->VDisplay) {
+                test = NULL;
+                break;
+            }
+        }
+
+        /* if we didn't match it on all outputs, try the next one */
+        if (!test)
+            continue;
+
+        /* if it's bigger than the last one, save it */
+        if (!match || (test->HDisplay > match->HDisplay))
+            match = test;
     }
 
     /* return the biggest one found */
@@ -2042,8 +1984,8 @@ bestModeForAspect(xf86CrtcConfigPtr config, Bool *enabled, float aspect)
 
 static Bool
 xf86TargetPreferred(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
-		    DisplayModePtr *modes, Bool *enabled,
-		    int width, int height)
+                    DisplayModePtr * modes, Bool *enabled,
+                    int width, int height)
 {
     int o, p;
     int max_pref_width = 0, max_pref_height = 0;
@@ -2054,91 +1996,95 @@ xf86TargetPreferred(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
     preferred_match = xnfcalloc(config->num_output, sizeof(DisplayModePtr));
 
     /* Check if the preferred mode is available on all outputs */
-    for (p = -1; nextEnabledOutput(config, enabled, &p); ) {
-	Rotation r = config->output[p]->initial_rotation;
-	DisplayModePtr mode;
-	if ((preferred[p] = xf86OutputHasPreferredMode(config->output[p],
-			width, height))) {
-	    int pref_width = xf86ModeWidth(preferred[p], r);
-	    int pref_height = xf86ModeHeight(preferred[p], r);
-	    Bool all_match = TRUE;
-
-	    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-		Bool match = FALSE;
-		xf86OutputPtr output = config->output[o];
-		if (o == p)
-		    continue;
-
-		/*
-		 * First see if the preferred mode matches on the next
-		 * output as well.  This catches the common case of identical
-		 * monitors and makes sure they all have the same timings
-		 * and refresh.  If that fails, we fall back to trying to
-		 * match just width & height.
-		 */
-		mode = xf86OutputHasPreferredMode(output, pref_width,
-						  pref_height);
-		if (mode && xf86ModesEqual(mode, preferred[p])) {
-			preferred[o] = mode;
-			match = TRUE;
-		} else {
-			for (mode = output->probed_modes; mode;
-			     mode = mode->next) {
-				Rotation r = output->initial_rotation;
-				if (xf86ModeWidth(mode, r) == pref_width &&
-				    xf86ModeHeight(mode, r) == pref_height) {
-					preferred[o] = mode;
-					match = TRUE;
-				}
-			}
-		}
-
-		all_match &= match;
-	    }
-
-	    if (all_match &&
-		    (pref_width*pref_height > max_pref_width*max_pref_height)) {
-		for (o = -1; nextEnabledOutput(config, enabled, &o); )
-		    preferred_match[o] = preferred[o];
-		max_pref_width = pref_width;
-		max_pref_height = pref_height;
-		ret = TRUE;
-	    }
-	}
+    for (p = -1; nextEnabledOutput(config, enabled, &p);) {
+        Rotation r = config->output[p]->initial_rotation;
+        DisplayModePtr mode;
+
+        if ((preferred[p] = xf86OutputHasPreferredMode(config->output[p],
+                                                       width, height))) {
+            int pref_width = xf86ModeWidth(preferred[p], r);
+            int pref_height = xf86ModeHeight(preferred[p], r);
+            Bool all_match = TRUE;
+
+            for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+                Bool match = FALSE;
+                xf86OutputPtr output = config->output[o];
+
+                if (o == p)
+                    continue;
+
+                /*
+                 * First see if the preferred mode matches on the next
+                 * output as well.  This catches the common case of identical
+                 * monitors and makes sure they all have the same timings
+                 * and refresh.  If that fails, we fall back to trying to
+                 * match just width & height.
+                 */
+                mode = xf86OutputHasPreferredMode(output, pref_width,
+                                                  pref_height);
+                if (mode && xf86ModesEqual(mode, preferred[p])) {
+                    preferred[o] = mode;
+                    match = TRUE;
+                }
+                else {
+                    for (mode = output->probed_modes; mode; mode = mode->next) {
+                        Rotation r = output->initial_rotation;
+
+                        if (xf86ModeWidth(mode, r) == pref_width &&
+                            xf86ModeHeight(mode, r) == pref_height) {
+                            preferred[o] = mode;
+                            match = TRUE;
+                        }
+                    }
+                }
+
+                all_match &= match;
+            }
+
+            if (all_match &&
+                (pref_width * pref_height > max_pref_width * max_pref_height)) {
+                for (o = -1; nextEnabledOutput(config, enabled, &o);)
+                    preferred_match[o] = preferred[o];
+                max_pref_width = pref_width;
+                max_pref_height = pref_height;
+                ret = TRUE;
+            }
+        }
     }
 
     /*
      * If there's no preferred mode, but only one monitor, pick the
      * biggest mode for its aspect ratio, assuming one exists.
      */
-    if (!ret) do {
-	int i = 0;
-	float aspect = 0.0;
+    if (!ret)
+        do {
+            int i = 0;
+            float aspect = 0.0;
 
-	/* count the number of enabled outputs */
-	for (i = 0, p = -1; nextEnabledOutput(config, enabled, &p); i++) ;
+            /* count the number of enabled outputs */
+            for (i = 0, p = -1; nextEnabledOutput(config, enabled, &p); i++);
 
-	if (i != 1)
-	    break;
+            if (i != 1)
+                break;
 
-	p = -1;
-	nextEnabledOutput(config, enabled, &p);
-	if (config->output[p]->mm_height)
-	    aspect = (float)config->output[p]->mm_width /
-		     (float)config->output[p]->mm_height;
+            p = -1;
+            nextEnabledOutput(config, enabled, &p);
+            if (config->output[p]->mm_height)
+                aspect = (float) config->output[p]->mm_width /
+                    (float) config->output[p]->mm_height;
 
-	if (aspect)
-	    preferred_match[p] = bestModeForAspect(config, enabled, aspect);
+            if (aspect)
+                preferred_match[p] = bestModeForAspect(config, enabled, aspect);
 
-	if (preferred_match[p])
-	    ret = TRUE;
+            if (preferred_match[p])
+                ret = TRUE;
 
-    } while (0);
+        } while (0);
 
     if (ret) {
-	/* oh good, there is a match.  stash the selected modes and return. */
-	memcpy(modes, preferred_match,
-		config->num_output * sizeof(DisplayModePtr));
+        /* oh good, there is a match.  stash the selected modes and return. */
+        memcpy(modes, preferred_match,
+               config->num_output * sizeof(DisplayModePtr));
     }
 
     free(preferred);
@@ -2148,8 +2094,7 @@ xf86TargetPreferred(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
 
 static Bool
 xf86TargetAspect(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
-		 DisplayModePtr *modes, Bool *enabled,
-		 int width, int height)
+                 DisplayModePtr * modes, Bool *enabled, int width, int height)
 {
     int o;
     float aspect = 0.0, *aspects;
@@ -2160,51 +2105,51 @@ xf86TargetAspect(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
     aspects = xnfcalloc(config->num_output, sizeof(float));
 
     /* collect the aspect ratios */
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	output = config->output[o];
-	if (output->mm_height)
-	    aspects[o] = (float)output->mm_width / (float)output->mm_height;
-	else
-	    aspects[o] = 4.0 / 3.0;
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        output = config->output[o];
+        if (output->mm_height)
+            aspects[o] = (float) output->mm_width / (float) output->mm_height;
+        else
+            aspects[o] = 4.0 / 3.0;
     }
 
     /* check that they're all the same */
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	output = config->output[o];
-	if (!aspect) {
-	    aspect = aspects[o];
-	} else if (!aspectMatch(aspect, aspects[o])) {
-	    goto no_aspect_match;
-	}
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        output = config->output[o];
+        if (!aspect) {
+            aspect = aspects[o];
+        }
+        else if (!aspectMatch(aspect, aspects[o])) {
+            goto no_aspect_match;
+        }
     }
 
     /* if they're all 4:3, just skip ahead and save effort */
-    if (!aspectMatch(aspect, 4.0/3.0))
-	aspect_guess = bestModeForAspect(config, enabled, aspect);
+    if (!aspectMatch(aspect, 4.0 / 3.0))
+        aspect_guess = bestModeForAspect(config, enabled, aspect);
 
-no_aspect_match:
-    base_guess = bestModeForAspect(config, enabled, 4.0/3.0);
+ no_aspect_match:
+    base_guess = bestModeForAspect(config, enabled, 4.0 / 3.0);
 
     guess = biggestMode(base_guess, aspect_guess);
 
     if (!guess)
-	goto out;
+        goto out;
 
     /* found a mode that works everywhere, now apply it */
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	modes[o] = xf86OutputFindClosestMode(config->output[o], guess);
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        modes[o] = xf86OutputFindClosestMode(config->output[o], guess);
     }
     ret = TRUE;
 
-out:
+ out:
     free(aspects);
     return ret;
 }
 
 static Bool
 xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
-		   DisplayModePtr *modes, Bool *enabled,
-		   int width, int height)
+                   DisplayModePtr * modes, Bool *enabled, int width, int height)
 {
     DisplayModePtr target_mode = NULL;
     Rotation target_rotation = RR_Rotate_0;
@@ -2212,30 +2157,30 @@ xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
     int default_preferred, target_preferred = 0, o;
 
     /* User preferred > preferred > other modes */
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	default_mode = xf86DefaultMode (config->output[o], width, height);
-	if (!default_mode)
-	    continue;
-
-	default_preferred = (((default_mode->type & M_T_PREFERRED) != 0) +
-		((default_mode->type & M_T_USERPREF) != 0));
-
-	if (default_preferred > target_preferred || !target_mode) {
-	    target_mode = default_mode;
-	    target_preferred = default_preferred;
-	    target_rotation = config->output[o]->initial_rotation;
-	    config->compat_output = o;
-	}
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        default_mode = xf86DefaultMode(config->output[o], width, height);
+        if (!default_mode)
+            continue;
+
+        default_preferred = (((default_mode->type & M_T_PREFERRED) != 0) +
+                             ((default_mode->type & M_T_USERPREF) != 0));
+
+        if (default_preferred > target_preferred || !target_mode) {
+            target_mode = default_mode;
+            target_preferred = default_preferred;
+            target_rotation = config->output[o]->initial_rotation;
+            config->compat_output = o;
+        }
     }
 
     if (target_mode)
-	modes[config->compat_output] = target_mode;
+        modes[config->compat_output] = target_mode;
 
     /* Fill in other output modes */
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	if (!modes[o])
-	    modes[o] = xf86ClosestMode(config->output[o], target_mode,
-				       target_rotation, width, height);
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        if (!modes[o])
+            modes[o] = xf86ClosestMode(config->output[o], target_mode,
+                                       target_rotation, width, height);
     }
 
     return target_mode != NULL;
@@ -2243,25 +2188,24 @@ xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
 
 static Bool
 xf86TargetUserpref(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
-		   DisplayModePtr *modes, Bool *enabled,
-		   int width, int height)
+                   DisplayModePtr * modes, Bool *enabled, int width, int height)
 {
     int o;
 
     if (xf86UserConfiguredOutputs(scrn, modes))
-	return xf86TargetFallback(scrn, config, modes, enabled, width, height);
-    
-    for (o = -1; nextEnabledOutput(config, enabled, &o); )
-	if (xf86OutputHasUserPreferredMode(config->output[o]))
-	    return 
-		xf86TargetFallback(scrn, config, modes, enabled, width, height);
+        return xf86TargetFallback(scrn, config, modes, enabled, width, height);
+
+    for (o = -1; nextEnabledOutput(config, enabled, &o);)
+        if (xf86OutputHasUserPreferredMode(config->output[o]))
+            return
+                xf86TargetFallback(scrn, config, modes, enabled, width, height);
 
     return FALSE;
 }
 
 static Bool
 xf86CrtcSetInitialGamma(xf86CrtcPtr crtc, float gamma_red, float gamma_green,
-        float gamma_blue)
+                        float gamma_blue)
 {
     int i, size = 256;
     CARD16 *red, *green, *blue;
@@ -2270,14 +2214,16 @@ xf86CrtcSetInitialGamma(xf86CrtcPtr crtc, float gamma_red, float gamma_green,
     green = red + size;
     blue = green + size;
 
-     /* Only cause warning if user wanted gamma to be set. */
-    if (!crtc->funcs->gamma_set && (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0)) {
+    /* Only cause warning if user wanted gamma to be set. */
+    if (!crtc->funcs->gamma_set &&
+        (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0)) {
         free(red);
         return FALSE;
-    } else if (!crtc->funcs->gamma_set) {
+    }
+    else if (!crtc->funcs->gamma_set) {
         free(red);
         return TRUE;
-      }
+    }
 
     /* At this early stage none of the randr-interface stuff is up.
      * So take the default gamma size for lack of something better.
@@ -2286,32 +2232,37 @@ xf86CrtcSetInitialGamma(xf86CrtcPtr crtc, float gamma_red, float gamma_green,
         if (gamma_red == 1.0)
             red[i] = i << 8;
         else
-            red[i] = (CARD16)(pow((double)i/(double)(size - 1),
-			1. / (double)gamma_red) * (double)(size - 1) * 256);
+            red[i] = (CARD16) (pow((double) i / (double) (size - 1),
+                                   1. / (double) gamma_red) * (double) (size -
+                                                                        1) *
+                               256);
 
         if (gamma_green == 1.0)
             green[i] = i << 8;
         else
-            green[i] = (CARD16)(pow((double)i/(double)(size - 1),
-			1. / (double)gamma_green) * (double)(size - 1) * 256);
+            green[i] = (CARD16) (pow((double) i / (double) (size - 1),
+                                     1. / (double) gamma_green) *
+                                 (double) (size - 1) * 256);
 
         if (gamma_blue == 1.0)
             blue[i] = i << 8;
         else
-            blue[i] = (CARD16)(pow((double)i/(double)(size - 1),
-			1. / (double)gamma_blue) * (double)(size - 1) * 256);
+            blue[i] = (CARD16) (pow((double) i / (double) (size - 1),
+                                    1. / (double) gamma_blue) * (double) (size -
+                                                                          1) *
+                                256);
     }
 
     /* Default size is 256, so anything else is failure. */
     if (size != crtc->gamma_size) {
         free(red);
         return FALSE;
-      }
+    }
 
     crtc->gamma_size = size;
-    memcpy (crtc->gamma_red, red, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_green, green, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_blue, blue, crtc->gamma_size * sizeof (CARD16));
+    memcpy(crtc->gamma_red, red, crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_green, green, crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_blue, blue, crtc->gamma_size * sizeof(CARD16));
 
     /* Do not set gamma now, delay until the crtc is activated. */
 
@@ -2325,7 +2276,7 @@ xf86OutputSetInitialGamma(xf86OutputPtr output)
 {
     XF86ConfMonitorPtr mon = output->conf_monitor;
     float gamma_red = 1.0, gamma_green = 1.0, gamma_blue = 1.0;
-    
+
     if (!mon)
         return TRUE;
 
@@ -2333,24 +2284,25 @@ xf86OutputSetInitialGamma(xf86OutputPtr output)
         return FALSE;
 
     /* Get configured values, where they exist. */
-    if (mon->mon_gamma_red >= GAMMA_MIN &&
-        mon->mon_gamma_red <= GAMMA_MAX)
-            gamma_red = mon->mon_gamma_red;
+    if (mon->mon_gamma_red >= GAMMA_MIN && mon->mon_gamma_red <= GAMMA_MAX)
+        gamma_red = mon->mon_gamma_red;
 
-    if (mon->mon_gamma_green >= GAMMA_MIN &&
-        mon->mon_gamma_green <= GAMMA_MAX)
-            gamma_green = mon->mon_gamma_green;
+    if (mon->mon_gamma_green >= GAMMA_MIN && mon->mon_gamma_green <= GAMMA_MAX)
+        gamma_green = mon->mon_gamma_green;
 
-    if (mon->mon_gamma_blue >= GAMMA_MIN &&
-        mon->mon_gamma_blue <= GAMMA_MAX)
-            gamma_blue = mon->mon_gamma_blue;
+    if (mon->mon_gamma_blue >= GAMMA_MIN && mon->mon_gamma_blue <= GAMMA_MAX)
+        gamma_blue = mon->mon_gamma_blue;
 
     /* This avoids setting gamma 1.0 in case another cloned output on this crtc has a specific gamma. */
     if (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0) {
-	xf86DrvMsg(output->scrn->scrnIndex, X_INFO, "Output %s wants gamma correction (%.1f, %.1f, %.1f)\n", output->name, gamma_red, gamma_green, gamma_blue);
-	return xf86CrtcSetInitialGamma(output->crtc, gamma_red, gamma_green, gamma_blue);
-    }else
-	return TRUE;
+        xf86DrvMsg(output->scrn->scrnIndex, X_INFO,
+                   "Output %s wants gamma correction (%.1f, %.1f, %.1f)\n",
+                   output->name, gamma_red, gamma_green, gamma_blue);
+        return xf86CrtcSetInitialGamma(output->crtc, gamma_red, gamma_green,
+                                       gamma_blue);
+    }
+    else
+        return TRUE;
 }
 
 /**
@@ -2368,177 +2320,183 @@ xf86OutputSetInitialGamma(xf86OutputPtr output)
  */
 
 Bool
-xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
-{
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o, c;
-    xf86CrtcPtr		*crtcs;
-    DisplayModePtr	*modes;
-    Bool		*enabled;
-    int			width, height;
-    int			i = scrn->scrnIndex;
+xf86InitialConfiguration(ScrnInfoPtr scrn, Bool canGrow)
+{
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o, c;
+    xf86CrtcPtr *crtcs;
+    DisplayModePtr *modes;
+    Bool *enabled;
+    int width, height;
+    int i = scrn->scrnIndex;
     Bool have_outputs = TRUE;
     Bool ret;
     Bool success = FALSE;
 
     /* Set up the device options */
-    config->options = xnfalloc (sizeof (xf86DeviceOptions));
-    memcpy (config->options, xf86DeviceOptions, sizeof (xf86DeviceOptions));
-    xf86ProcessOptions (scrn->scrnIndex,
-			scrn->options,
-			config->options);
-    config->debug_modes = xf86ReturnOptValBool (config->options,
-						OPTION_MODEDEBUG, FALSE);
+    config->options = xnfalloc(sizeof(xf86DeviceOptions));
+    memcpy(config->options, xf86DeviceOptions, sizeof(xf86DeviceOptions));
+    xf86ProcessOptions(scrn->scrnIndex, scrn->options, config->options);
+    config->debug_modes = xf86ReturnOptValBool(config->options,
+                                               OPTION_MODEDEBUG, FALSE);
 
     if (scrn->display->virtualX)
-	width = scrn->display->virtualX;
+        width = scrn->display->virtualX;
     else
-	width = config->maxWidth;
+        width = config->maxWidth;
     if (scrn->display->virtualY)
-	height = scrn->display->virtualY;
+        height = scrn->display->virtualY;
     else
-	height = config->maxHeight;
+        height = config->maxHeight;
 
-    xf86ProbeOutputModes (scrn, width, height);
+    xf86ProbeOutputModes(scrn, width, height);
+
+    crtcs = xnfcalloc(config->num_output, sizeof(xf86CrtcPtr));
+    modes = xnfcalloc(config->num_output, sizeof(DisplayModePtr));
+    enabled = xnfcalloc(config->num_output, sizeof(Bool));
 
-    crtcs = xnfcalloc (config->num_output, sizeof (xf86CrtcPtr));
-    modes = xnfcalloc (config->num_output, sizeof (DisplayModePtr));
-    enabled = xnfcalloc (config->num_output, sizeof (Bool));
-    
     ret = xf86CollectEnabledOutputs(scrn, config, enabled);
     if (ret == FALSE && canGrow) {
-	xf86DrvMsg(i, X_WARNING, "Unable to find connected outputs - setting %dx%d initial framebuffer\n",
-		   NO_OUTPUT_DEFAULT_WIDTH, NO_OUTPUT_DEFAULT_HEIGHT);
-	have_outputs = FALSE;
-    } else {
-	if (xf86TargetUserpref(scrn, config, modes, enabled, width, height))
-	    xf86DrvMsg(i, X_INFO, "Using user preference for initial modes\n");
-	else if (xf86TargetPreferred(scrn, config, modes, enabled, width, height))
-	    xf86DrvMsg(i, X_INFO, "Using exact sizes for initial modes\n");
-	else if (xf86TargetAspect(scrn, config, modes, enabled, width, height))
-	    xf86DrvMsg(i, X_INFO, "Using fuzzy aspect match for initial modes\n");
-	else if (xf86TargetFallback(scrn, config, modes, enabled, width, height))
-	    xf86DrvMsg(i, X_INFO, "Using sloppy heuristic for initial modes\n");
-	else
-	    xf86DrvMsg(i, X_WARNING, "Unable to find initial modes\n");
-    }
-
-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
-	if (!modes[o])
-	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
-			"Output %s enabled but has no modes\n",
-			config->output[o]->name);
-	else
-	    xf86DrvMsg (scrn->scrnIndex, X_INFO,
-			"Output %s using initial mode %s\n",
-			config->output[o]->name, modes[o]->name);
+        xf86DrvMsg(i, X_WARNING,
+                   "Unable to find connected outputs - setting %dx%d initial framebuffer\n",
+                   NO_OUTPUT_DEFAULT_WIDTH, NO_OUTPUT_DEFAULT_HEIGHT);
+        have_outputs = FALSE;
+    }
+    else {
+        if (xf86TargetUserpref(scrn, config, modes, enabled, width, height))
+            xf86DrvMsg(i, X_INFO, "Using user preference for initial modes\n");
+        else if (xf86TargetPreferred
+                 (scrn, config, modes, enabled, width, height))
+            xf86DrvMsg(i, X_INFO, "Using exact sizes for initial modes\n");
+        else if (xf86TargetAspect(scrn, config, modes, enabled, width, height))
+            xf86DrvMsg(i, X_INFO,
+                       "Using fuzzy aspect match for initial modes\n");
+        else if (xf86TargetFallback
+                 (scrn, config, modes, enabled, width, height))
+            xf86DrvMsg(i, X_INFO, "Using sloppy heuristic for initial modes\n");
+        else
+            xf86DrvMsg(i, X_WARNING, "Unable to find initial modes\n");
+    }
+
+    for (o = -1; nextEnabledOutput(config, enabled, &o);) {
+        if (!modes[o])
+            xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+                       "Output %s enabled but has no modes\n",
+                       config->output[o]->name);
+        else
+            xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                       "Output %s using initial mode %s\n",
+                       config->output[o]->name, modes[o]->name);
     }
 
     /*
      * Set the position of each output
      */
-    if (!xf86InitialOutputPositions (scrn, modes))
-	goto bailout;
+    if (!xf86InitialOutputPositions(scrn, modes))
+        goto bailout;
 
     /*
      * Set initial panning of each output
      */
-    xf86InitialPanning (scrn);
-	
+    xf86InitialPanning(scrn);
+
     /*
      * Assign CRTCs to fit output configuration
      */
-    if (have_outputs && !xf86PickCrtcs (scrn, crtcs, modes, 0, width, height))
-	goto bailout;
-    
+    if (have_outputs && !xf86PickCrtcs(scrn, crtcs, modes, 0, width, height))
+        goto bailout;
+
     /* XXX override xf86 common frame computation code */
-    
+
     scrn->display->frameX0 = 0;
     scrn->display->frameY0 = 0;
-    
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr	crtc = config->crtc[c];
 
-	crtc->enabled = FALSE;
-	memset (&crtc->desiredMode, '\0', sizeof (crtc->desiredMode));
-	/* Set default gamma for all crtc's. */
-	/* This is done to avoid problems later on with cloned outputs. */
-	xf86CrtcSetInitialGamma(crtc, 1.0, 1.0, 1.0);
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        crtc->enabled = FALSE;
+        memset(&crtc->desiredMode, '\0', sizeof(crtc->desiredMode));
+        /* Set default gamma for all crtc's. */
+        /* This is done to avoid problems later on with cloned outputs. */
+        xf86CrtcSetInitialGamma(crtc, 1.0, 1.0, 1.0);
     }
 
     if (xf86_crtc_supports_gamma(scrn))
-	xf86DrvMsg(scrn->scrnIndex, X_INFO, "Using default gamma of (1.0, 1.0, 1.0) unless otherwise stated.\n");
+        xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                   "Using default gamma of (1.0, 1.0, 1.0) unless otherwise stated.\n");
 
     /*
      * Set initial configuration
      */
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
-	DisplayModePtr	mode = modes[o];
-        xf86CrtcPtr	crtc = crtcs[o];
-
-	if (mode && crtc)
-	{
-	    crtc->desiredMode = *mode;
-	    crtc->desiredRotation = output->initial_rotation;
-	    crtc->desiredX = output->initial_x;
-	    crtc->desiredY = output->initial_y;
-	    crtc->desiredTransformPresent = FALSE;
-	    crtc->enabled = TRUE;
-	    memcpy (&crtc->panningTotalArea,    &output->initialTotalArea,    sizeof(BoxRec));
-	    memcpy (&crtc->panningTrackingArea, &output->initialTrackingArea, sizeof(BoxRec));
-	    memcpy (crtc->panningBorder,        output->initialBorder,        4*sizeof(INT16));
-	    output->crtc = crtc;
-	    if (!xf86OutputSetInitialGamma(output))
-		xf86DrvMsg (scrn->scrnIndex, X_WARNING, "Initial gamma correction for output %s: failed.\n", output->name);
-	} else {
-	    output->crtc = NULL;
-	}
-    }
-
-    if (scrn->display->virtualX == 0)
-    {
-	/*
-	 * Expand virtual size to cover the current config and potential mode
-	 * switches, if the driver can't enlarge the screen later.
-	 */
-	xf86DefaultScreenLimits (scrn, &width, &height, canGrow);
-    
-	if (have_outputs == FALSE) {
-	    if (width < NO_OUTPUT_DEFAULT_WIDTH && height < NO_OUTPUT_DEFAULT_HEIGHT) {
-		width = NO_OUTPUT_DEFAULT_WIDTH;
-		height = NO_OUTPUT_DEFAULT_HEIGHT;
-	    }
-	}
-
-	scrn->display->virtualX = width;
-	scrn->display->virtualY = height;
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        DisplayModePtr mode = modes[o];
+        xf86CrtcPtr crtc = crtcs[o];
+
+        if (mode && crtc) {
+            crtc->desiredMode = *mode;
+            crtc->desiredRotation = output->initial_rotation;
+            crtc->desiredX = output->initial_x;
+            crtc->desiredY = output->initial_y;
+            crtc->desiredTransformPresent = FALSE;
+            crtc->enabled = TRUE;
+            memcpy(&crtc->panningTotalArea, &output->initialTotalArea,
+                   sizeof(BoxRec));
+            memcpy(&crtc->panningTrackingArea, &output->initialTrackingArea,
+                   sizeof(BoxRec));
+            memcpy(crtc->panningBorder, output->initialBorder,
+                   4 * sizeof(INT16));
+            output->crtc = crtc;
+            if (!xf86OutputSetInitialGamma(output))
+                xf86DrvMsg(scrn->scrnIndex, X_WARNING,
+                           "Initial gamma correction for output %s: failed.\n",
+                           output->name);
+        }
+        else {
+            output->crtc = NULL;
+        }
+    }
+
+    if (scrn->display->virtualX == 0) {
+        /*
+         * Expand virtual size to cover the current config and potential mode
+         * switches, if the driver can't enlarge the screen later.
+         */
+        xf86DefaultScreenLimits(scrn, &width, &height, canGrow);
+
+        if (have_outputs == FALSE) {
+            if (width < NO_OUTPUT_DEFAULT_WIDTH &&
+                height < NO_OUTPUT_DEFAULT_HEIGHT) {
+                width = NO_OUTPUT_DEFAULT_WIDTH;
+                height = NO_OUTPUT_DEFAULT_HEIGHT;
+            }
+        }
+
+        scrn->display->virtualX = width;
+        scrn->display->virtualY = height;
     }
 
     if (width > scrn->virtualX)
-	scrn->virtualX = width;
+        scrn->virtualX = width;
     if (height > scrn->virtualY)
-	scrn->virtualY = height;
+        scrn->virtualY = height;
 
     /*
      * Make sure the configuration isn't too small.
      */
     if (width < config->minWidth || height < config->minHeight)
-	goto bailout;
+        goto bailout;
 
     /*
      * Limit the crtc config to virtual[XY] if the driver can't grow the
      * desktop.
      */
-    if (!canGrow)
-    {
-	xf86CrtcSetSizeRange (scrn, config->minWidth, config->minHeight,
-			      width, height);
+    if (!canGrow) {
+        xf86CrtcSetSizeRange(scrn, config->minWidth, config->minHeight,
+                             width, height);
     }
 
-    xf86SetScrnInfoModes (scrn);
+    xf86SetScrnInfoModes(scrn);
 
     success = TRUE;
  bailout:
@@ -2554,58 +2512,58 @@ xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
  * since the driver will have to re-route things.
  */
 static void
-xf86PrepareOutputs (ScrnInfoPtr scrn)
+xf86PrepareOutputs(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			o;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
 
     for (o = 0; o < config->num_output; o++) {
-	xf86OutputPtr output = config->output[o];
+        xf86OutputPtr output = config->output[o];
+
 #if RANDR_GET_CRTC_INTERFACE
-	/* Disable outputs that are unused or will be re-routed */
-	if (!output->funcs->get_crtc ||
-	    output->crtc != (*output->funcs->get_crtc)(output) ||
-	    output->crtc == NULL)
+        /* Disable outputs that are unused or will be re-routed */
+        if (!output->funcs->get_crtc ||
+            output->crtc != (*output->funcs->get_crtc) (output) ||
+            output->crtc == NULL)
 #endif
-	    (*output->funcs->dpms)(output, DPMSModeOff);
+            (*output->funcs->dpms) (output, DPMSModeOff);
     }
 }
 
 static void
-xf86PrepareCrtcs (ScrnInfoPtr scrn)
+xf86PrepareCrtcs(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     for (c = 0; c < config->num_crtc; c++) {
 #if RANDR_GET_CRTC_INTERFACE
-	xf86CrtcPtr	crtc = config->crtc[c];
-	xf86OutputPtr	output = NULL;
-	uint32_t	desired_outputs = 0, current_outputs = 0;
-	int		o;
-
-	for (o = 0; o < config->num_output; o++) {
-	    output = config->output[o];
-	    if (output->crtc == crtc)
-		desired_outputs |= (1<<o);
-	    /* If we can't tell where it's mapped, force it off */
-	    if (!output->funcs->get_crtc) {
-		desired_outputs = 0;
-		break;
-	    }
-	    if ((*output->funcs->get_crtc)(output) == crtc)
-		current_outputs |= (1<<o);
-	}
-
-	/*
-	 * If mappings are different or the CRTC is unused,
-	 * we need to disable it
-	 */
-	if (desired_outputs != current_outputs ||
-	    !desired_outputs)
-	    (*crtc->funcs->dpms)(crtc, DPMSModeOff);
+        xf86CrtcPtr crtc = config->crtc[c];
+        xf86OutputPtr output = NULL;
+        uint32_t desired_outputs = 0, current_outputs = 0;
+        int o;
+
+        for (o = 0; o < config->num_output; o++) {
+            output = config->output[o];
+            if (output->crtc == crtc)
+                desired_outputs |= (1 << o);
+            /* If we can't tell where it's mapped, force it off */
+            if (!output->funcs->get_crtc) {
+                desired_outputs = 0;
+                break;
+            }
+            if ((*output->funcs->get_crtc) (output) == crtc)
+                current_outputs |= (1 << o);
+        }
+
+        /*
+         * If mappings are different or the CRTC is unused,
+         * we need to disable it
+         */
+        if (desired_outputs != current_outputs || !desired_outputs)
+            (*crtc->funcs->dpms) (crtc, DPMSModeOff);
 #else
-	(*crtc->funcs->dpms)(crtc, DPMSModeOff);
+        (*crtc->funcs->dpms) (crtc, DPMSModeOff);
 #endif
     }
 }
@@ -2616,67 +2574,65 @@ xf86PrepareCrtcs (ScrnInfoPtr scrn)
  */
 
 Bool
-xf86SetDesiredModes (ScrnInfoPtr scrn)
+xf86SetDesiredModes(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CrtcPtr         crtc = config->crtc[0];
-    int			c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcPtr crtc = config->crtc[0];
+    int c;
 
     /* A driver with this hook will take care of this */
     if (!crtc->funcs->set_mode_major) {
-	xf86PrepareOutputs(scrn);
-	xf86PrepareCrtcs(scrn);
-    }
-
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86OutputPtr	output = NULL;
-	int		o;
-	RRTransformPtr	transform;
-
-	crtc = config->crtc[c];
-
-	/* Skip disabled CRTCs */
-	if (!crtc->enabled)
-	    continue;
-
-	if (xf86CompatOutput(scrn) && xf86CompatCrtc(scrn) == crtc)
-	    output = xf86CompatOutput(scrn);
-	else
-	{
-	    for (o = 0; o < config->num_output; o++)
-		if (config->output[o]->crtc == crtc)
-		{
-		    output = config->output[o];
-		    break;
-		}
-	}
-	/* paranoia */
-	if (!output)
-	    continue;
-
-	/* Mark that we'll need to re-set the mode for sure */
-	memset(&crtc->mode, 0, sizeof(crtc->mode));
-	if (!crtc->desiredMode.CrtcHDisplay)
-	{
-	    DisplayModePtr  mode = xf86OutputFindClosestMode (output, scrn->currentMode);
-
-	    if (!mode)
-		return FALSE;
-	    crtc->desiredMode = *mode;
-	    crtc->desiredRotation = RR_Rotate_0;
-	    crtc->desiredTransformPresent = FALSE;
-	    crtc->desiredX = 0;
-	    crtc->desiredY = 0;
-	}
-
-	if (crtc->desiredTransformPresent)
-	    transform = &crtc->desiredTransform;
-	else
-	    transform = NULL;
-	if (!xf86CrtcSetModeTransform (crtc, &crtc->desiredMode, crtc->desiredRotation,
-				       transform, crtc->desiredX, crtc->desiredY))
-	    return FALSE;
+        xf86PrepareOutputs(scrn);
+        xf86PrepareCrtcs(scrn);
+    }
+
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86OutputPtr output = NULL;
+        int o;
+        RRTransformPtr transform;
+
+        crtc = config->crtc[c];
+
+        /* Skip disabled CRTCs */
+        if (!crtc->enabled)
+            continue;
+
+        if (xf86CompatOutput(scrn) && xf86CompatCrtc(scrn) == crtc)
+            output = xf86CompatOutput(scrn);
+        else {
+            for (o = 0; o < config->num_output; o++)
+                if (config->output[o]->crtc == crtc) {
+                    output = config->output[o];
+                    break;
+                }
+        }
+        /* paranoia */
+        if (!output)
+            continue;
+
+        /* Mark that we'll need to re-set the mode for sure */
+        memset(&crtc->mode, 0, sizeof(crtc->mode));
+        if (!crtc->desiredMode.CrtcHDisplay) {
+            DisplayModePtr mode =
+                xf86OutputFindClosestMode(output, scrn->currentMode);
+
+            if (!mode)
+                return FALSE;
+            crtc->desiredMode = *mode;
+            crtc->desiredRotation = RR_Rotate_0;
+            crtc->desiredTransformPresent = FALSE;
+            crtc->desiredX = 0;
+            crtc->desiredY = 0;
+        }
+
+        if (crtc->desiredTransformPresent)
+            transform = &crtc->desiredTransform;
+        else
+            transform = NULL;
+        if (!xf86CrtcSetModeTransform
+            (crtc, &crtc->desiredMode, crtc->desiredRotation, transform,
+             crtc->desiredX, crtc->desiredY))
+            return FALSE;
     }
 
     xf86DisableUnusedFunctions(scrn);
@@ -2694,56 +2650,52 @@ xf86SetDesiredModes (ScrnInfoPtr scrn)
  */
 
 DisplayModePtr
-xf86OutputFindClosestMode (xf86OutputPtr output, DisplayModePtr desired)
-{
-    DisplayModePtr	best = NULL, scan = NULL;
-
-    for (scan = output->probed_modes; scan != NULL; scan = scan->next) 
-    {
-	/* If there's an exact match, we're done. */
-	if (xf86ModesEqual(scan, desired)) {
-	    best = desired;
-	    break;
-	}
-
-	/* Reject if it's larger than the desired mode. */
-	if (scan->HDisplay > desired->HDisplay || 
-	    scan->VDisplay > desired->VDisplay)
-	{
-	    continue;
-	}
-
-	/*
-	 * If we haven't picked a best mode yet, use the first
-	 * one in the size range
-	 */
-	if (best == NULL) 
-	{
-	    best = scan;
-	    continue;
-	}
-
-	/* Find if it's closer to the right size than the current best
-	 * option.
-	 */
-	if ((scan->HDisplay > best->HDisplay &&
-	     scan->VDisplay >= best->VDisplay) ||
-	    (scan->HDisplay >= best->HDisplay &&
-	     scan->VDisplay > best->VDisplay))
-	{
-	    best = scan;
-	    continue;
-	}
-
-	/* Find if it's still closer to the right refresh than the current
-	 * best resolution.
-	 */
-	if (scan->HDisplay == best->HDisplay &&
-	    scan->VDisplay == best->VDisplay &&
-	    (fabs(scan->VRefresh - desired->VRefresh) <
-	     fabs(best->VRefresh - desired->VRefresh))) {
-	    best = scan;
-	}
+xf86OutputFindClosestMode(xf86OutputPtr output, DisplayModePtr desired)
+{
+    DisplayModePtr best = NULL, scan = NULL;
+
+    for (scan = output->probed_modes; scan != NULL; scan = scan->next) {
+        /* If there's an exact match, we're done. */
+        if (xf86ModesEqual(scan, desired)) {
+            best = desired;
+            break;
+        }
+
+        /* Reject if it's larger than the desired mode. */
+        if (scan->HDisplay > desired->HDisplay ||
+            scan->VDisplay > desired->VDisplay) {
+            continue;
+        }
+
+        /*
+         * If we haven't picked a best mode yet, use the first
+         * one in the size range
+         */
+        if (best == NULL) {
+            best = scan;
+            continue;
+        }
+
+        /* Find if it's closer to the right size than the current best
+         * option.
+         */
+        if ((scan->HDisplay > best->HDisplay &&
+             scan->VDisplay >= best->VDisplay) ||
+            (scan->HDisplay >= best->HDisplay &&
+             scan->VDisplay > best->VDisplay)) {
+            best = scan;
+            continue;
+        }
+
+        /* Find if it's still closer to the right refresh than the current
+         * best resolution.
+         */
+        if (scan->HDisplay == best->HDisplay &&
+            scan->VDisplay == best->VDisplay &&
+            (fabs(scan->VRefresh - desired->VRefresh) <
+             fabs(best->VRefresh - desired->VRefresh))) {
+            best = scan;
+        }
     }
     return best;
 }
@@ -2757,74 +2709,68 @@ xf86OutputFindClosestMode (xf86OutputPtr output, DisplayModePtr desired)
  */
 
 Bool
-xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)
+xf86SetSingleMode(ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);
-    Bool		ok = TRUE;
-    xf86OutputPtr	compat_output;
-    DisplayModePtr	compat_mode = NULL;
-    int			c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    Bool ok = TRUE;
+    xf86OutputPtr compat_output;
+    DisplayModePtr compat_mode = NULL;
+    int c;
 
     /*
      * Let the compat output drive the final mode selection
      */
     compat_output = xf86CompatOutput(pScrn);
     if (compat_output)
-	compat_mode = xf86OutputFindClosestMode (compat_output, desired);
+        compat_mode = xf86OutputFindClosestMode(compat_output, desired);
     if (compat_mode)
-	desired = compat_mode;
-    
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr	crtc = config->crtc[c];
-	DisplayModePtr	crtc_mode = NULL;
-	int		o;
-
-	if (!crtc->enabled)
-	    continue;
-	
-	for (o = 0; o < config->num_output; o++)
-	{
-	    xf86OutputPtr   output = config->output[o];
-	    DisplayModePtr  output_mode;
-
-	    /* skip outputs not on this crtc */
-	    if (output->crtc != crtc)
-		continue;
-	    
-	    if (crtc_mode)
-	    {
-		output_mode = xf86OutputFindClosestMode (output, crtc_mode);
-		if (output_mode != crtc_mode)
-		    output->crtc = NULL;
-	    }
-	    else
-		crtc_mode = xf86OutputFindClosestMode (output, desired);
-	}
-	if (!crtc_mode)
-	{
-	    crtc->enabled = FALSE;
-	    continue;
-	}
-	if (!xf86CrtcSetModeTransform (crtc, crtc_mode, rotation, NULL, 0, 0))
-	    ok = FALSE;
-	else
-	{
-	    crtc->desiredMode = *crtc_mode;
-	    crtc->desiredRotation = rotation;
-	    crtc->desiredTransformPresent = FALSE;
-	    crtc->desiredX = 0;
-	    crtc->desiredY = 0;
-	}
+        desired = compat_mode;
+
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+        DisplayModePtr crtc_mode = NULL;
+        int o;
+
+        if (!crtc->enabled)
+            continue;
+
+        for (o = 0; o < config->num_output; o++) {
+            xf86OutputPtr output = config->output[o];
+            DisplayModePtr output_mode;
+
+            /* skip outputs not on this crtc */
+            if (output->crtc != crtc)
+                continue;
+
+            if (crtc_mode) {
+                output_mode = xf86OutputFindClosestMode(output, crtc_mode);
+                if (output_mode != crtc_mode)
+                    output->crtc = NULL;
+            }
+            else
+                crtc_mode = xf86OutputFindClosestMode(output, desired);
+        }
+        if (!crtc_mode) {
+            crtc->enabled = FALSE;
+            continue;
+        }
+        if (!xf86CrtcSetModeTransform(crtc, crtc_mode, rotation, NULL, 0, 0))
+            ok = FALSE;
+        else {
+            crtc->desiredMode = *crtc_mode;
+            crtc->desiredRotation = rotation;
+            crtc->desiredTransformPresent = FALSE;
+            crtc->desiredX = 0;
+            crtc->desiredY = 0;
+        }
     }
     xf86DisableUnusedFunctions(pScrn);
 #ifdef RANDR_12_INTERFACE
-    xf86RandR12TellChanged (pScrn->pScreen);
+    xf86RandR12TellChanged(pScrn->pScreen);
 #endif
     return ok;
 }
 
-
 /**
  * Set the DPMS power mode of all outputs and CRTCs.
  *
@@ -2834,32 +2780,35 @@ xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)
 void
 xf86DPMSSet(ScrnInfoPtr scrn, int mode, int flags)
 {
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			i;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    int i;
 
     if (!scrn->vtSema)
-	return;
+        return;
 
     if (mode == DPMSModeOff) {
-	for (i = 0; i < config->num_output; i++) {
-	    xf86OutputPtr output = config->output[i];
-	    if (output->crtc != NULL)
-		(*output->funcs->dpms) (output, mode);
-	}
+        for (i = 0; i < config->num_output; i++) {
+            xf86OutputPtr output = config->output[i];
+
+            if (output->crtc != NULL)
+                (*output->funcs->dpms) (output, mode);
+        }
     }
 
     for (i = 0; i < config->num_crtc; i++) {
-	xf86CrtcPtr crtc = config->crtc[i];
-	if (crtc->enabled)
-	    (*crtc->funcs->dpms) (crtc, mode);
+        xf86CrtcPtr crtc = config->crtc[i];
+
+        if (crtc->enabled)
+            (*crtc->funcs->dpms) (crtc, mode);
     }
 
     if (mode != DPMSModeOff) {
-	for (i = 0; i < config->num_output; i++) {
-	    xf86OutputPtr output = config->output[i];
-	    if (output->crtc != NULL)
-		(*output->funcs->dpms) (output, mode);
-	}
+        for (i = 0; i < config->num_output; i++) {
+            xf86OutputPtr output = config->output[i];
+
+            if (output->crtc != NULL)
+                (*output->funcs->dpms) (output, mode);
+        }
     }
 }
 
@@ -2875,9 +2824,9 @@ xf86SaveScreen(ScreenPtr pScreen, int mode)
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 
     if (xf86IsUnblank(mode))
-	xf86DPMSSet(pScrn, DPMSModeOn, 0);
+        xf86DPMSSet(pScrn, DPMSModeOn, 0);
     else
-	xf86DPMSSet(pScrn, DPMSModeOff, 0);
+        xf86DPMSSet(pScrn, DPMSModeOff, 0);
 
     return TRUE;
 }
@@ -2888,32 +2837,30 @@ xf86SaveScreen(ScreenPtr pScreen, int mode)
 void
 xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			o, c;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int o, c;
+
+    for (o = 0; o < xf86_config->num_output; o++) {
+        xf86OutputPtr output = xf86_config->output[o];
 
-    for (o = 0; o < xf86_config->num_output; o++) 
-    {
-	xf86OutputPtr  output = xf86_config->output[o];
-	if (!output->crtc) 
-	    (*output->funcs->dpms)(output, DPMSModeOff);
+        if (!output->crtc)
+            (*output->funcs->dpms) (output, DPMSModeOff);
     }
 
-    for (c = 0; c < xf86_config->num_crtc; c++) 
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (!crtc->enabled) 
-	{
-	    crtc->funcs->dpms(crtc, DPMSModeOff);
-	    memset(&crtc->mode, 0, sizeof(crtc->mode));
-	    xf86RotateDestroy(crtc);
-	    crtc->active = FALSE;
-	}
+        if (!crtc->enabled) {
+            crtc->funcs->dpms(crtc, DPMSModeOff);
+            memset(&crtc->mode, 0, sizeof(crtc->mode));
+            xf86RotateDestroy(crtc);
+            crtc->active = FALSE;
+        }
     }
     if (pScrn->pScreen)
-	xf86_crtc_notify(pScrn->pScreen);
+        xf86_crtc_notify(pScrn->pScreen);
     if (pScrn->ModeSet)
-	pScrn->ModeSet(pScrn);
+        pScrn->ModeSet(pScrn);
 }
 
 #ifdef RANDR_12_INTERFACE
@@ -2924,19 +2871,20 @@ xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)
  * Set the RandR EDID property
  */
 static void
-xf86OutputSetEDIDProperty (xf86OutputPtr output, void *data, int data_len)
+xf86OutputSetEDIDProperty(xf86OutputPtr output, void *data, int data_len)
 {
     Atom edid_atom = MakeAtom(EDID_ATOM_NAME, sizeof(EDID_ATOM_NAME) - 1, TRUE);
 
     /* This may get called before the RandR resources have been created */
     if (output->randr_output == NULL)
-	return;
+        return;
 
     if (data_len != 0) {
-	RRChangeOutputProperty(output->randr_output, edid_atom, XA_INTEGER, 8,
-			       PropModeReplace, data_len, data, FALSE, TRUE);
-    } else {
-	RRDeleteOutputProperty(output->randr_output, edid_atom);
+        RRChangeOutputProperty(output->randr_output, edid_atom, XA_INTEGER, 8,
+                               PropModeReplace, data_len, data, FALSE, TRUE);
+    }
+    else {
+        RRDeleteOutputProperty(output->randr_output, edid_atom);
     }
 }
 
@@ -2949,14 +2897,16 @@ struct det_phySize_parameter {
     Bool ret;
 };
 
-static void  handle_detailed_physical_size(struct detailed_monitor_section
-		                          *det_mon, void *data)
+static void
+handle_detailed_physical_size(struct detailed_monitor_section
+                              *det_mon, void *data)
 {
     struct det_phySize_parameter *p;
-    p = (struct det_phySize_parameter *)data;
 
-    if (p->ret == TRUE )
-        return ;
+    p = (struct det_phySize_parameter *) data;
+
+    if (p->ret == TRUE)
+        return;
 
     xf86DetTimingApplyQuirks(det_mon, p->quirks,
                              p->output->MonInfo->features.hsize,
@@ -2975,25 +2925,26 @@ static void  handle_detailed_physical_size(struct detailed_monitor_section
  * Set the EDID information for the specified output
  */
 void
-xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)
+xf86OutputSetEDID(xf86OutputPtr output, xf86MonPtr edid_mon)
 {
-    ScrnInfoPtr		scrn = output->scrn;
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    Bool		debug_modes = config->debug_modes || xf86Initialising;
+    ScrnInfoPtr scrn = output->scrn;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+    Bool debug_modes = config->debug_modes || xf86Initialising;
+
 #ifdef RANDR_12_INTERFACE
-    int			size;
+    int size;
 #endif
-    
+
     free(output->MonInfo);
-    
+
     output->MonInfo = edid_mon;
     output->mm_width = 0;
     output->mm_height = 0;
 
     if (debug_modes) {
-	xf86DrvMsg(scrn->scrnIndex, X_INFO, "EDID for output %s\n",
-		   output->name);
-	xf86PrintEDID(edid_mon);
+        xf86DrvMsg(scrn->scrnIndex, X_INFO, "EDID for output %s\n",
+                   output->name);
+        xf86PrintEDID(edid_mon);
     }
 
     /* Set the DDC properties for the 'compat' output */
@@ -3003,34 +2954,34 @@ xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)
 #ifdef RANDR_12_INTERFACE
     /* Set the RandR output properties */
     size = 0;
-    if (edid_mon)
-    {
-	if (edid_mon->ver.version == 1) {
-	    size = 128;
-	    if (edid_mon->flags & EDID_COMPLETE_RAWDATA)
-		size += edid_mon->no_sections * 128;
-	} else if (edid_mon->ver.version == 2)
-	    size = 256;
-    }
-    xf86OutputSetEDIDProperty (output, edid_mon ? edid_mon->rawData : NULL, size);
+    if (edid_mon) {
+        if (edid_mon->ver.version == 1) {
+            size = 128;
+            if (edid_mon->flags & EDID_COMPLETE_RAWDATA)
+                size += edid_mon->no_sections * 128;
+        }
+        else if (edid_mon->ver.version == 2)
+            size = 256;
+    }
+    xf86OutputSetEDIDProperty(output, edid_mon ? edid_mon->rawData : NULL,
+                              size);
 #endif
 
     if (edid_mon) {
 
         struct det_phySize_parameter p;
+
         p.output = output;
-        p.quirks = xf86DDCDetectQuirks(scrn->scrnIndex,edid_mon, FALSE);
+        p.quirks = xf86DDCDetectQuirks(scrn->scrnIndex, edid_mon, FALSE);
         p.ret = FALSE;
-        xf86ForEachDetailedBlock(edid_mon,
-                                 handle_detailed_physical_size, &p);
+        xf86ForEachDetailedBlock(edid_mon, handle_detailed_physical_size, &p);
 
-	/* if no mm size is available from a detailed timing, check the max size field */
-	if ((!output->mm_width || !output->mm_height) &&
-	    (edid_mon->features.hsize && edid_mon->features.vsize))
-	{
-	    output->mm_width = edid_mon->features.hsize * 10;
-	    output->mm_height = edid_mon->features.vsize * 10;
-	}
+        /* if no mm size is available from a detailed timing, check the max size field */
+        if ((!output->mm_width || !output->mm_height) &&
+            (edid_mon->features.hsize && edid_mon->features.vsize)) {
+            output->mm_width = edid_mon->features.hsize * 10;
+            output->mm_height = edid_mon->features.vsize * 10;
+        }
     }
 }
 
@@ -3039,21 +2990,21 @@ xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)
  * stored in 'output'
  */
 DisplayModePtr
-xf86OutputGetEDIDModes (xf86OutputPtr output)
+xf86OutputGetEDIDModes(xf86OutputPtr output)
 {
-    ScrnInfoPtr	scrn = output->scrn;
-    xf86MonPtr	edid_mon = output->MonInfo;
+    ScrnInfoPtr scrn = output->scrn;
+    xf86MonPtr edid_mon = output->MonInfo;
 
     if (!edid_mon)
-	return NULL;
+        return NULL;
     return xf86DDCGetModes(scrn->scrnIndex, edid_mon);
 }
 
 /* maybe we should care about DDC1?  meh. */
 xf86MonPtr
-xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)
+xf86OutputGetEDID(xf86OutputPtr output, I2CBusPtr pDDCBus)
 {
-    ScrnInfoPtr	scrn = output->scrn;
+    ScrnInfoPtr scrn = output->scrn;
     xf86MonPtr mon;
 
     mon = xf86DoEEDID(scrn->scrnIndex, pDDCBus, TRUE);
@@ -3064,11 +3015,12 @@ xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)
 }
 
 static const char *_xf86ConnectorNames[] = {
-					"None", "VGA", "DVI-I", "DVI-D",
-					"DVI-A", "Composite", "S-Video",
-					"Component", "LFP", "Proprietary",
-					"HDMI", "DisplayPort",
-				     };
+    "None", "VGA", "DVI-I", "DVI-D",
+    "DVI-A", "Composite", "S-Video",
+    "Component", "LFP", "Proprietary",
+    "HDMI", "DisplayPort",
+};
+
 const char *
 xf86ConnectorGetName(xf86ConnectorType connector)
 {
@@ -3084,19 +3036,20 @@ x86_crtc_box_intersect(BoxPtr dest, BoxPtr a, BoxPtr b)
     dest->y2 = a->y2 < b->y2 ? a->y2 : b->y2;
 
     if (dest->x1 >= dest->x2 || dest->y1 >= dest->y2)
-	dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;
+        dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;
 }
 
 static void
 x86_crtc_box(xf86CrtcPtr crtc, BoxPtr crtc_box)
 {
     if (crtc->enabled) {
-	crtc_box->x1 = crtc->x;
-	crtc_box->x2 = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
-	crtc_box->y1 = crtc->y;
-	crtc_box->y2 = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);
-    } else
-	crtc_box->x1 = crtc_box->x2 = crtc_box->y1 = crtc_box->y2 = 0;
+        crtc_box->x1 = crtc->x;
+        crtc_box->x2 = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
+        crtc_box->y1 = crtc->y;
+        crtc_box->y2 = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);
+    }
+    else
+        crtc_box->x1 = crtc_box->x2 = crtc_box->y1 = crtc_box->y2 = 0;
 }
 
 static int
@@ -3114,15 +3067,13 @@ xf86_crtc_box_area(BoxPtr box)
 
 static xf86CrtcPtr
 xf86_covering_crtc(ScrnInfoPtr pScrn,
-		   BoxPtr      box,
-		   xf86CrtcPtr desired,
-		   BoxPtr      crtc_box_ret)
+                   BoxPtr box, xf86CrtcPtr desired, BoxPtr crtc_box_ret)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    xf86CrtcPtr		crtc, best_crtc;
-    int			coverage, best_coverage;
-    int			c;
-    BoxRec		crtc_box, cover_box;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    xf86CrtcPtr crtc, best_crtc;
+    int coverage, best_coverage;
+    int c;
+    BoxRec crtc_box, cover_box;
 
     best_crtc = NULL;
     best_coverage = 0;
@@ -3131,18 +3082,19 @@ xf86_covering_crtc(ScrnInfoPtr pScrn,
     crtc_box_ret->y1 = 0;
     crtc_box_ret->y2 = 0;
     for (c = 0; c < xf86_config->num_crtc; c++) {
-	crtc = xf86_config->crtc[c];
-	x86_crtc_box(crtc, &crtc_box);
-	x86_crtc_box_intersect(&cover_box, &crtc_box, box);
-	coverage = xf86_crtc_box_area(&cover_box);
-	if (coverage && crtc == desired) {
-	    *crtc_box_ret = crtc_box;
-	    return crtc;
-	} else if (coverage > best_coverage) {
-	    *crtc_box_ret = crtc_box;
-	    best_crtc = crtc;
-	    best_coverage = coverage;
-	}
+        crtc = xf86_config->crtc[c];
+        x86_crtc_box(crtc, &crtc_box);
+        x86_crtc_box_intersect(&cover_box, &crtc_box, box);
+        coverage = xf86_crtc_box_area(&cover_box);
+        if (coverage && crtc == desired) {
+            *crtc_box_ret = crtc_box;
+            return crtc;
+        }
+        else if (coverage > best_coverage) {
+            *crtc_box_ret = crtc_box;
+            best_crtc = crtc;
+            best_coverage = coverage;
+        }
     }
     return best_crtc;
 }
@@ -3157,57 +3109,53 @@ xf86_covering_crtc(ScrnInfoPtr pScrn,
 
 Bool
 xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,
-			    xf86CrtcPtr *crtc_ret,
-			    xf86CrtcPtr desired_crtc,
-			    BoxPtr      dst,
-			    INT32	*xa,
-			    INT32	*xb,
-			    INT32	*ya,
-			    INT32	*yb,
-			    RegionPtr   reg,
-			    INT32	width,
-			    INT32	height)
-{
-    Bool	ret;
-    RegionRec	crtc_region_local;
-    RegionPtr	crtc_region = reg;
-    
-    if (crtc_ret) {
-	BoxRec		crtc_box;
-	xf86CrtcPtr	crtc = xf86_covering_crtc(pScrn, dst,
-						  desired_crtc,
-						  &crtc_box);
+                            xf86CrtcPtr * crtc_ret,
+                            xf86CrtcPtr desired_crtc,
+                            BoxPtr dst,
+                            INT32 *xa,
+                            INT32 *xb,
+                            INT32 *ya,
+                            INT32 *yb, RegionPtr reg, INT32 width, INT32 height)
+{
+    Bool ret;
+    RegionRec crtc_region_local;
+    RegionPtr crtc_region = reg;
 
-	if (crtc) {
-	    RegionInit(&crtc_region_local, &crtc_box, 1);
-	    crtc_region = &crtc_region_local;
-	    RegionIntersect(crtc_region, crtc_region, reg);
-	}
-	*crtc_ret = crtc;
+    if (crtc_ret) {
+        BoxRec crtc_box;
+        xf86CrtcPtr crtc = xf86_covering_crtc(pScrn, dst,
+                                              desired_crtc,
+                                              &crtc_box);
+
+        if (crtc) {
+            RegionInit(&crtc_region_local, &crtc_box, 1);
+            crtc_region = &crtc_region_local;
+            RegionIntersect(crtc_region, crtc_region, reg);
+        }
+        *crtc_ret = crtc;
     }
 
-    ret = xf86XVClipVideoHelper(dst, xa, xb, ya, yb, 
-				crtc_region, width, height);
+    ret = xf86XVClipVideoHelper(dst, xa, xb, ya, yb,
+                                crtc_region, width, height);
 
     if (crtc_region != reg)
-	RegionUninit(&crtc_region_local);
+        RegionUninit(&crtc_region_local);
 
     return ret;
 }
 #endif
 
 xf86_crtc_notify_proc_ptr
-xf86_wrap_crtc_notify (ScreenPtr screen, xf86_crtc_notify_proc_ptr new)
-{
-    if (xf86CrtcConfigPrivateIndex != -1)
-    {
-	ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-	xf86_crtc_notify_proc_ptr	old;
-	
-	old = config->xf86_crtc_notify;
-	config->xf86_crtc_notify = new;
-	return old;
+xf86_wrap_crtc_notify(ScreenPtr screen, xf86_crtc_notify_proc_ptr new)
+{
+    if (xf86CrtcConfigPrivateIndex != -1) {
+        ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+        xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+        xf86_crtc_notify_proc_ptr old;
+
+        old = config->xf86_crtc_notify;
+        config->xf86_crtc_notify = new;
+        return old;
     }
     return NULL;
 }
@@ -3215,40 +3163,39 @@ xf86_wrap_crtc_notify (ScreenPtr screen, xf86_crtc_notify_proc_ptr new)
 void
 xf86_unwrap_crtc_notify(ScreenPtr screen, xf86_crtc_notify_proc_ptr old)
 {
-    if (xf86CrtcConfigPrivateIndex != -1)
-    {
-	ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    
-	config->xf86_crtc_notify = old;
+    if (xf86CrtcConfigPrivateIndex != -1) {
+        ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+        xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+
+        config->xf86_crtc_notify = old;
     }
 }
 
 void
 xf86_crtc_notify(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
-    
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
+
     if (config->xf86_crtc_notify)
-	config->xf86_crtc_notify(screen);
+        config->xf86_crtc_notify(screen);
 }
 
 Bool
 xf86_crtc_supports_gamma(ScrnInfoPtr pScrn)
 {
     if (xf86CrtcConfigPrivateIndex != -1) {
-	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-	xf86CrtcPtr crtc;
+        xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+        xf86CrtcPtr crtc;
 
-	/* for multiple drivers loaded we need this */
-	if (!xf86_config)
-		return FALSE;
-	if (xf86_config->num_crtc == 0)
-	    return FALSE;
-	crtc = xf86_config->crtc[0];
+        /* for multiple drivers loaded we need this */
+        if (!xf86_config)
+            return FALSE;
+        if (xf86_config->num_crtc == 0)
+            return FALSE;
+        crtc = xf86_config->crtc[0];
 
-	return crtc->funcs->gamma_set != NULL;
+        return crtc->funcs->gamma_set != NULL;
     }
 
     return FALSE;
diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.h b/xorg-server/hw/xfree86/modes/xf86Crtc.h
index 8d4a08938..a6a3c2e95 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.h
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.h
@@ -53,24 +53,24 @@ typedef struct _xf86Output xf86OutputRec, *xf86OutputPtr;
 
 /* define a standard for connector types */
 typedef enum _xf86ConnectorType {
-   XF86ConnectorNone,
-   XF86ConnectorVGA,
-   XF86ConnectorDVI_I,
-   XF86ConnectorDVI_D,
-   XF86ConnectorDVI_A,
-   XF86ConnectorComposite,
-   XF86ConnectorSvideo,
-   XF86ConnectorComponent,
-   XF86ConnectorLFP,
-   XF86ConnectorProprietary,
-   XF86ConnectorHDMI,
-   XF86ConnectorDisplayPort,
+    XF86ConnectorNone,
+    XF86ConnectorVGA,
+    XF86ConnectorDVI_I,
+    XF86ConnectorDVI_D,
+    XF86ConnectorDVI_A,
+    XF86ConnectorComposite,
+    XF86ConnectorSvideo,
+    XF86ConnectorComponent,
+    XF86ConnectorLFP,
+    XF86ConnectorProprietary,
+    XF86ConnectorHDMI,
+    XF86ConnectorDisplayPort,
 } xf86ConnectorType;
 
 typedef enum _xf86OutputStatus {
-   XF86OutputStatusConnected,
-   XF86OutputStatusDisconnected,
-   XF86OutputStatusUnknown
+    XF86OutputStatusConnected,
+    XF86OutputStatusDisconnected,
+    XF86OutputStatusUnknown
 } xf86OutputStatus;
 
 typedef struct _xf86CrtcFuncs {
@@ -81,35 +81,34 @@ typedef struct _xf86CrtcFuncs {
     * mode is DPMSModeOff, the crtc must be disabled sufficiently for it to
     * be safe to call mode_set.
     */
-   void
-    (*dpms)(xf86CrtcPtr		crtc,
-	    int		    	mode);
+    void
+     (*dpms) (xf86CrtcPtr crtc, int mode);
 
    /**
     * Saves the crtc's state for restoration on VT switch.
     */
-   void
-    (*save)(xf86CrtcPtr		crtc);
+    void
+     (*save) (xf86CrtcPtr crtc);
 
    /**
     * Restore's the crtc's state at VT switch.
     */
-   void
-    (*restore)(xf86CrtcPtr	crtc);
+    void
+     (*restore) (xf86CrtcPtr crtc);
 
     /**
      * Lock CRTC prior to mode setting, mostly for DRI.
      * Returns whether unlock is needed
      */
     Bool
-    (*lock) (xf86CrtcPtr crtc);
-    
+     (*lock) (xf86CrtcPtr crtc);
+
     /**
      * Unlock CRTC after mode setting, mostly for DRI
      */
     void
-    (*unlock) (xf86CrtcPtr crtc);
-    
+     (*unlock) (xf86CrtcPtr crtc);
+
     /**
      * Callback to adjust the mode to be set in the CRTC.
      *
@@ -118,109 +117,106 @@ typedef struct _xf86CrtcFuncs {
      * buses with clock limitations.
      */
     Bool
-    (*mode_fixup)(xf86CrtcPtr crtc,
-		  DisplayModePtr mode,
-		  DisplayModePtr adjusted_mode);
+     (*mode_fixup) (xf86CrtcPtr crtc,
+                    DisplayModePtr mode, DisplayModePtr adjusted_mode);
 
     /**
      * Prepare CRTC for an upcoming mode set.
      */
     void
-    (*prepare)(xf86CrtcPtr crtc);
+     (*prepare) (xf86CrtcPtr crtc);
 
     /**
      * Callback for setting up a video mode after fixups have been made.
      */
     void
-    (*mode_set)(xf86CrtcPtr crtc,
-		DisplayModePtr mode,
-		DisplayModePtr adjusted_mode,
-		int x, int y);
+     (*mode_set) (xf86CrtcPtr crtc,
+                  DisplayModePtr mode,
+                  DisplayModePtr adjusted_mode, int x, int y);
 
     /**
      * Commit mode changes to a CRTC
      */
     void
-    (*commit)(xf86CrtcPtr crtc);
+     (*commit) (xf86CrtcPtr crtc);
 
     /* Set the color ramps for the CRTC to the given values. */
     void
-    (*gamma_set)(xf86CrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue,
-		 int size);
+     (*gamma_set) (xf86CrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue,
+                   int size);
 
     /**
      * Allocate the shadow area, delay the pixmap creation until needed
      */
-    void *
-    (*shadow_allocate) (xf86CrtcPtr crtc, int width, int height);
-    
+    void *(*shadow_allocate) (xf86CrtcPtr crtc, int width, int height);
+
     /**
      * Create shadow pixmap for rotation support
      */
     PixmapPtr
-    (*shadow_create) (xf86CrtcPtr crtc, void *data, int width, int height);
-    
+     (*shadow_create) (xf86CrtcPtr crtc, void *data, int width, int height);
+
     /**
      * Destroy shadow pixmap
      */
     void
-    (*shadow_destroy) (xf86CrtcPtr crtc, PixmapPtr pPixmap, void *data);
+     (*shadow_destroy) (xf86CrtcPtr crtc, PixmapPtr pPixmap, void *data);
 
     /**
      * Set cursor colors
      */
     void
-    (*set_cursor_colors) (xf86CrtcPtr crtc, int bg, int fg);
+     (*set_cursor_colors) (xf86CrtcPtr crtc, int bg, int fg);
 
     /**
      * Set cursor position
      */
     void
-    (*set_cursor_position) (xf86CrtcPtr crtc, int x, int y);
+     (*set_cursor_position) (xf86CrtcPtr crtc, int x, int y);
 
     /**
      * Show cursor
      */
     void
-    (*show_cursor) (xf86CrtcPtr crtc);
+     (*show_cursor) (xf86CrtcPtr crtc);
 
     /**
      * Hide cursor
      */
     void
-    (*hide_cursor) (xf86CrtcPtr crtc);
+     (*hide_cursor) (xf86CrtcPtr crtc);
 
     /**
      * Load monochrome image
      */
     void
-    (*load_cursor_image) (xf86CrtcPtr crtc, CARD8 *image);
+     (*load_cursor_image) (xf86CrtcPtr crtc, CARD8 *image);
 
     /**
      * Load ARGB image
      */
-     void
+    void
      (*load_cursor_argb) (xf86CrtcPtr crtc, CARD32 *image);
-     
+
     /**
      * Clean up driver-specific bits of the crtc
      */
     void
-    (*destroy) (xf86CrtcPtr	crtc);
+     (*destroy) (xf86CrtcPtr crtc);
 
     /**
      * Less fine-grained mode setting entry point for kernel modesetting
      */
     Bool
-    (*set_mode_major)(xf86CrtcPtr crtc, DisplayModePtr mode,
-		      Rotation rotation, int x, int y);
+     (*set_mode_major) (xf86CrtcPtr crtc, DisplayModePtr mode,
+                        Rotation rotation, int x, int y);
 
     /**
      * Callback for panning. Doesn't change the mode.
      * Added in ABI version 2
      */
     void
-    (*set_origin)(xf86CrtcPtr crtc, int x, int y);
+     (*set_origin) (xf86CrtcPtr crtc, int x, int y);
 
 } xf86CrtcFuncsRec, *xf86CrtcFuncsPtr;
 
@@ -235,15 +231,15 @@ struct _xf86Crtc {
     /**
      * Associated ScrnInfo
      */
-    ScrnInfoPtr	    scrn;
-    
+    ScrnInfoPtr scrn;
+
     /**
      * Desired state of this CRTC
      *
      * Set when this CRTC should be driving one or more outputs 
      */
-    Bool	    enabled;
-    
+    Bool enabled;
+
     /**
      * Active mode
      *
@@ -251,18 +247,18 @@ struct _xf86Crtc {
      * It will be cleared when the VT is not active or
      * during server startup
      */
-    DisplayModeRec  mode;
-    Rotation	    rotation;
-    PixmapPtr	    rotatedPixmap;
-    void	    *rotatedData;
-    
+    DisplayModeRec mode;
+    Rotation rotation;
+    PixmapPtr rotatedPixmap;
+    void *rotatedData;
+
     /**
      * Position on screen
      *
      * Locates this CRTC within the frame buffer
      */
-    int		    x, y;
-    
+    int x, y;
+
     /**
      * Desired mode
      *
@@ -271,10 +267,10 @@ struct _xf86Crtc {
      * the startup configured mode and saves the active mode
      * on VT switch.
      */
-    DisplayModeRec  desiredMode;
-    Rotation	    desiredRotation;
-    int		    desiredX, desiredY;
-    
+    DisplayModeRec desiredMode;
+    Rotation desiredRotation;
+    int desiredX, desiredY;
+
     /** crtc-specific functions */
     const xf86CrtcFuncsRec *funcs;
 
@@ -283,7 +279,7 @@ struct _xf86Crtc {
      *
      * Holds driver-private information
      */
-    void	    *driver_private;
+    void *driver_private;
 
 #ifdef RANDR_12_INTERFACE
     /**
@@ -292,45 +288,45 @@ struct _xf86Crtc {
      * When RandR 1.2 is available, this
      * points at the associated crtc object
      */
-    RRCrtcPtr	    randr_crtc;
+    RRCrtcPtr randr_crtc;
 #else
-    void	    *randr_crtc;
+    void *randr_crtc;
 #endif
 
     /**
      * Current cursor is ARGB
      */
-    Bool	    cursor_argb;
+    Bool cursor_argb;
     /**
      * Track whether cursor is within CRTC range 
      */
-    Bool	    cursor_in_range;
+    Bool cursor_in_range;
     /**
      * Track state of cursor associated with this CRTC
      */
-    Bool	    cursor_shown;
+    Bool cursor_shown;
 
     /**
      * Current transformation matrix
      */
-    PictTransform   crtc_to_framebuffer;
+    PictTransform crtc_to_framebuffer;
     /* framebuffer_to_crtc was removed in ABI 2 */
-    struct pict_f_transform f_crtc_to_framebuffer; /* ABI 2 */
-    struct pict_f_transform f_framebuffer_to_crtc; /* ABI 2 */
-    PictFilterPtr   filter; /* ABI 2 */
-    xFixed	    *params; /* ABI 2 */
-    int		    nparams; /* ABI 2 */
-    int		    filter_width; /* ABI 2 */
-    int		    filter_height; /* ABI 2 */
-    Bool	    transform_in_use;
-    RRTransformRec  transform; /* ABI 2 */
-    Bool	    transformPresent; /* ABI 2 */
-    RRTransformRec  desiredTransform; /* ABI 2 */
-    Bool	    desiredTransformPresent; /* ABI 2 */
+    struct pict_f_transform f_crtc_to_framebuffer;      /* ABI 2 */
+    struct pict_f_transform f_framebuffer_to_crtc;      /* ABI 2 */
+    PictFilterPtr filter;       /* ABI 2 */
+    xFixed *params;             /* ABI 2 */
+    int nparams;                /* ABI 2 */
+    int filter_width;           /* ABI 2 */
+    int filter_height;          /* ABI 2 */
+    Bool transform_in_use;
+    RRTransformRec transform;   /* ABI 2 */
+    Bool transformPresent;      /* ABI 2 */
+    RRTransformRec desiredTransform;    /* ABI 2 */
+    Bool desiredTransformPresent;       /* ABI 2 */
     /**
      * Bounding box in screen space
      */
-    BoxRec	    bounds;
+    BoxRec bounds;
     /**
      * Panning:
      * TotalArea: total panning area, larger than CRTC's size
@@ -338,9 +334,9 @@ struct _xf86Crtc {
      * border: Borders of the displayed CRTC area which induces panning if the pointer reaches them
      * Added in ABI version 2
      */
-    BoxRec          panningTotalArea;
-    BoxRec          panningTrackingArea;
-    INT16           panningBorder[4];
+    BoxRec panningTotalArea;
+    BoxRec panningTrackingArea;
+    INT16 panningBorder[4];
 
     /**
      * Current gamma, especially useful after initial config.
@@ -357,11 +353,11 @@ struct _xf86Crtc {
      * Set to TRUE after modesetting, set to FALSE if no outputs are connected
      * Added in ABI version 3
      */
-    Bool	    active;
+    Bool active;
     /**
      * Clear the shadow
      */
-    Bool	    shadowClear;
+    Bool shadowClear;
 
     /**
      * Indicates that the driver is handling the transform, so the shadow
@@ -374,7 +370,7 @@ struct _xf86Crtc {
      *
      * Added in ABI version 4
      */
-    Bool	    driverIsPerformingTransform;
+    Bool driverIsPerformingTransform;
 };
 
 typedef struct _xf86OutputFuncs {
@@ -383,7 +379,7 @@ typedef struct _xf86OutputFuncs {
      * RandR objects have been created.
      */
     void
-    (*create_resources)(xf86OutputPtr output);
+     (*create_resources) (xf86OutputPtr output);
 
     /**
      * Turns the output on/off, or sets intermediate power levels if available.
@@ -393,20 +389,19 @@ typedef struct _xf86OutputFuncs {
      * disabled afterwards.
      */
     void
-    (*dpms)(xf86OutputPtr	output,
-	    int			mode);
+     (*dpms) (xf86OutputPtr output, int mode);
 
     /**
      * Saves the output's state for restoration on VT switch.
      */
     void
-    (*save)(xf86OutputPtr	output);
+     (*save) (xf86OutputPtr output);
 
     /**
      * Restore's the output's state at VT switch.
      */
     void
-    (*restore)(xf86OutputPtr	output);
+     (*restore) (xf86OutputPtr output);
 
     /**
      * Callback for testing a video mode for a given output.
@@ -417,8 +412,7 @@ typedef struct _xf86OutputFuncs {
      * \return MODE_OK if the mode is valid, or another MODE_* otherwise.
      */
     int
-    (*mode_valid)(xf86OutputPtr	    output,
-		  DisplayModePtr    pMode);
+     (*mode_valid) (xf86OutputPtr output, DisplayModePtr pMode);
 
     /**
      * Callback to adjust the mode to be set in the CRTC.
@@ -428,21 +422,20 @@ typedef struct _xf86OutputFuncs {
      * buses with clock limitations.
      */
     Bool
-    (*mode_fixup)(xf86OutputPtr output,
-		  DisplayModePtr mode,
-		  DisplayModePtr adjusted_mode);
+     (*mode_fixup) (xf86OutputPtr output,
+                    DisplayModePtr mode, DisplayModePtr adjusted_mode);
 
     /**
      * Callback for preparing mode changes on an output
      */
     void
-    (*prepare)(xf86OutputPtr output);
+     (*prepare) (xf86OutputPtr output);
 
     /**
      * Callback for committing mode changes on an output
      */
     void
-    (*commit)(xf86OutputPtr output);
+     (*commit) (xf86OutputPtr output);
 
     /**
      * Callback for setting up a video mode after fixups have been made.
@@ -452,15 +445,13 @@ typedef struct _xf86OutputFuncs {
      * after this function is called.
      */
     void
-    (*mode_set)(xf86OutputPtr  output,
-		DisplayModePtr mode,
-		DisplayModePtr adjusted_mode);
+     (*mode_set) (xf86OutputPtr output,
+                  DisplayModePtr mode, DisplayModePtr adjusted_mode);
 
     /**
      * Probe for a connected output, and return detect_status.
      */
-    xf86OutputStatus
-    (*detect)(xf86OutputPtr	    output);
+     xf86OutputStatus(*detect) (xf86OutputPtr output);
 
     /**
      * Query the device for the modes it provides.
@@ -469,41 +460,36 @@ typedef struct _xf86OutputFuncs {
      *
      * \return singly-linked list of modes or NULL if no modes found.
      */
-    DisplayModePtr
-    (*get_modes)(xf86OutputPtr	    output);
+     DisplayModePtr(*get_modes) (xf86OutputPtr output);
 
 #ifdef RANDR_12_INTERFACE
     /**
      * Callback when an output's property has changed.
      */
     Bool
-    (*set_property)(xf86OutputPtr output,
-		    Atom property,
-		    RRPropertyValuePtr value);
+     (*set_property) (xf86OutputPtr output,
+                      Atom property, RRPropertyValuePtr value);
 #endif
 #ifdef RANDR_13_INTERFACE
     /**
      * Callback to get an updated property value
      */
     Bool
-    (*get_property)(xf86OutputPtr output,
-		    Atom property);
+     (*get_property) (xf86OutputPtr output, Atom property);
 #endif
 #ifdef RANDR_GET_CRTC_INTERFACE
     /**
      * Callback to get current CRTC for a given output
      */
-    xf86CrtcPtr
-    (*get_crtc)(xf86OutputPtr output);
+     xf86CrtcPtr(*get_crtc) (xf86OutputPtr output);
 #endif
     /**
      * Clean up driver-specific bits of the output
      */
     void
-    (*destroy) (xf86OutputPtr	    output);
+     (*destroy) (xf86OutputPtr output);
 } xf86OutputFuncsRec, *xf86OutputFuncsPtr;
 
-
 #define XF86_OUTPUT_VERSION 2
 
 struct _xf86Output {
@@ -515,34 +501,34 @@ struct _xf86Output {
     /**
      * Associated ScrnInfo
      */
-    ScrnInfoPtr		scrn;
+    ScrnInfoPtr scrn;
 
     /**
      * Currently connected crtc (if any)
      *
      * If this output is not in use, this field will be NULL.
      */
-    xf86CrtcPtr		crtc;
+    xf86CrtcPtr crtc;
 
     /**
      * Possible CRTCs for this output as a mask of crtc indices
      */
-    CARD32		possible_crtcs;
+    CARD32 possible_crtcs;
 
     /**
      * Possible outputs to share the same CRTC as a mask of output indices
      */
-    CARD32		possible_clones;
-    
+    CARD32 possible_clones;
+
     /**
      * Whether this output can support interlaced modes
      */
-    Bool		interlaceAllowed;
+    Bool interlaceAllowed;
 
     /**
      * Whether this output can support double scan modes
      */
-    Bool		doubleScanAllowed;
+    Bool doubleScanAllowed;
 
     /**
      * List of available modes on this output.
@@ -550,27 +536,27 @@ struct _xf86Output {
      * This should be the list from get_modes(), plus perhaps additional
      * compatible modes added later.
      */
-    DisplayModePtr	probed_modes;
+    DisplayModePtr probed_modes;
 
     /**
      * Options parsed from the related monitor section
      */
-    OptionInfoPtr	options;
-    
+    OptionInfoPtr options;
+
     /**
      * Configured monitor section
      */
-    XF86ConfMonitorPtr  conf_monitor;
-    
+    XF86ConfMonitorPtr conf_monitor;
+
     /**
      * Desired initial position
      */
-    int			initial_x, initial_y;
+    int initial_x, initial_y;
 
     /**
      * Desired initial rotation
      */
-    Rotation		initial_rotation;
+    Rotation initial_rotation;
 
     /**
      * Current connection status
@@ -578,28 +564,28 @@ struct _xf86Output {
      * This indicates whether a monitor is known to be connected
      * to this output or not, or whether there is no way to tell
      */
-    xf86OutputStatus	status;
+    xf86OutputStatus status;
 
     /** EDID monitor information */
-    xf86MonPtr		MonInfo;
+    xf86MonPtr MonInfo;
 
     /** subpixel order */
-    int			subpixel_order;
+    int subpixel_order;
 
     /** Physical size of the currently attached output device. */
-    int			mm_width, mm_height;
+    int mm_width, mm_height;
 
     /** Output name */
-    char		*name;
+    char *name;
 
     /** output-specific functions */
     const xf86OutputFuncsRec *funcs;
 
     /** driver private information */
-    void		*driver_private;
-    
+    void *driver_private;
+
     /** Whether to use the old per-screen Monitor config section */
-    Bool		use_screen_monitor;
+    Bool use_screen_monitor;
 
 #ifdef RANDR_12_INTERFACE
     /**
@@ -608,17 +594,17 @@ struct _xf86Output {
      * When RandR 1.2 is available, this points at the associated
      * RandR output structure and is created when this output is created
      */
-    RROutputPtr		randr_output;
+    RROutputPtr randr_output;
 #else
-    void		*randr_output;
+    void *randr_output;
 #endif
     /** 
      * Desired initial panning
      * Added in ABI version 2
      */
-    BoxRec          initialTotalArea;
-    BoxRec          initialTrackingArea;
-    INT16           initialBorder[4];
+    BoxRec initialTotalArea;
+    BoxRec initialTrackingArea;
+    INT16 initialBorder[4];
 };
 
 typedef struct _xf86CrtcConfigFuncs {
@@ -635,67 +621,65 @@ typedef struct _xf86CrtcConfigFuncs {
      * pixmaps it may have moved, and change pScrn->displayWidth.
      */
     Bool
-    (*resize)(ScrnInfoPtr	scrn,
-	      int		width,
-	      int		height);
+     (*resize) (ScrnInfoPtr scrn, int width, int height);
 } xf86CrtcConfigFuncsRec, *xf86CrtcConfigFuncsPtr;
 
 typedef void (*xf86_crtc_notify_proc_ptr) (ScreenPtr pScreen);
 
 typedef struct _xf86CrtcConfig {
-    int			num_output;
-    xf86OutputPtr	*output;
+    int num_output;
+    xf86OutputPtr *output;
     /**
      * compat_output is used whenever we deal
      * with legacy code that only understands a single
      * output. pScrn->modes will be loaded from this output,
      * adjust frame will whack this output, etc.
      */
-    int			compat_output;
+    int compat_output;
+
+    int num_crtc;
+    xf86CrtcPtr *crtc;
 
-    int			num_crtc;
-    xf86CrtcPtr		*crtc;
+    int minWidth, minHeight;
+    int maxWidth, maxHeight;
 
-    int			minWidth, minHeight;
-    int			maxWidth, maxHeight;
-    
     /* For crtc-based rotation */
-    DamagePtr		rotation_damage;
-    Bool		rotation_damage_registered;
+    DamagePtr rotation_damage;
+    Bool rotation_damage_registered;
 
     /* DGA */
-    unsigned int	dga_flags;
-    unsigned long	dga_address;
-    DGAModePtr		dga_modes;
-    int			dga_nmode;
-    int			dga_width, dga_height, dga_stride;
-    DisplayModePtr	dga_save_mode;
+    unsigned int dga_flags;
+    unsigned long dga_address;
+    DGAModePtr dga_modes;
+    int dga_nmode;
+    int dga_width, dga_height, dga_stride;
+    DisplayModePtr dga_save_mode;
 
     const xf86CrtcConfigFuncsRec *funcs;
 
-    CreateScreenResourcesProcPtr    CreateScreenResources;
+    CreateScreenResourcesProcPtr CreateScreenResources;
 
-    CloseScreenProcPtr		    CloseScreen;
+    CloseScreenProcPtr CloseScreen;
 
     /* Cursor information */
-    xf86CursorInfoPtr	cursor_info;
-    CursorPtr		cursor;
-    CARD8		*cursor_image;
-    Bool		cursor_on;
-    CARD32		cursor_fg, cursor_bg;
+    xf86CursorInfoPtr cursor_info;
+    CursorPtr cursor;
+    CARD8 *cursor_image;
+    Bool cursor_on;
+    CARD32 cursor_fg, cursor_bg;
 
     /**
      * Options parsed from the related device section
      */
-    OptionInfoPtr	options;
+    OptionInfoPtr options;
 
-    Bool		debug_modes;
+    Bool debug_modes;
 
     /* wrap screen BlockHandler for rotation */
-    ScreenBlockHandlerProcPtr	BlockHandler;
+    ScreenBlockHandlerProcPtr BlockHandler;
 
     /* callback when crtc configuration changes */
-    xf86_crtc_notify_proc_ptr  xf86_crtc_notify;
+    xf86_crtc_notify_proc_ptr xf86_crtc_notify;
 
 } xf86CrtcConfigRec, *xf86CrtcConfigPtr;
 
@@ -707,6 +691,7 @@ static _X_INLINE xf86OutputPtr
 xf86CompatOutput(ScrnInfoPtr pScrn)
 {
     xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+
     return config->output[config->compat_output];
 }
 
@@ -714,156 +699,155 @@ static _X_INLINE xf86CrtcPtr
 xf86CompatCrtc(ScrnInfoPtr pScrn)
 {
     xf86OutputPtr compat_output = xf86CompatOutput(pScrn);
+
     if (!compat_output)
-	return NULL;
+        return NULL;
     return compat_output->crtc;
 }
 
 static _X_INLINE RRCrtcPtr
 xf86CompatRRCrtc(ScrnInfoPtr pScrn)
 {
-    xf86CrtcPtr	compat_crtc = xf86CompatCrtc(pScrn);
+    xf86CrtcPtr compat_crtc = xf86CompatCrtc(pScrn);
+
     if (!compat_crtc)
-	return NULL;
+        return NULL;
     return compat_crtc->randr_crtc;
 }
 
-
 /*
  * Initialize xf86CrtcConfig structure
  */
 
 extern _X_EXPORT void
-xf86CrtcConfigInit (ScrnInfoPtr				scrn,
-		    const xf86CrtcConfigFuncsRec	*funcs);
+ xf86CrtcConfigInit(ScrnInfoPtr scrn, const xf86CrtcConfigFuncsRec * funcs);
 
 extern _X_EXPORT void
-xf86CrtcSetSizeRange (ScrnInfoPtr scrn,
-		      int minWidth, int minHeight,
-		      int maxWidth, int maxHeight);
+
+xf86CrtcSetSizeRange(ScrnInfoPtr scrn,
+                     int minWidth, int minHeight, int maxWidth, int maxHeight);
 
 /*
  * Crtc functions
  */
 extern _X_EXPORT xf86CrtcPtr
-xf86CrtcCreate (ScrnInfoPtr		scrn,
-		const xf86CrtcFuncsRec	*funcs);
+xf86CrtcCreate(ScrnInfoPtr scrn, const xf86CrtcFuncsRec * funcs);
 
 extern _X_EXPORT void
-xf86CrtcDestroy (xf86CrtcPtr		crtc);
-
+ xf86CrtcDestroy(xf86CrtcPtr crtc);
 
 /**
  * Sets the given video mode on the given crtc
  */
 
 extern _X_EXPORT Bool
-xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
-			  RRTransformPtr transform, int x, int y);
+
+xf86CrtcSetModeTransform(xf86CrtcPtr crtc, DisplayModePtr mode,
+                         Rotation rotation, RRTransformPtr transform, int x,
+                         int y);
 
 extern _X_EXPORT Bool
-xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
-		 int x, int y);
+
+xf86CrtcSetMode(xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
+                int x, int y);
 
 extern _X_EXPORT void
-xf86CrtcSetOrigin (xf86CrtcPtr crtc, int x, int y);
+ xf86CrtcSetOrigin(xf86CrtcPtr crtc, int x, int y);
 
 /*
  * Assign crtc rotation during mode set
  */
 extern _X_EXPORT Bool
-xf86CrtcRotate (xf86CrtcPtr crtc);
+ xf86CrtcRotate(xf86CrtcPtr crtc);
 
 /*
  * Clean up any rotation data, used when a crtc is turned off
  * as well as when rotation is disabled.
  */
 extern _X_EXPORT void
-xf86RotateDestroy (xf86CrtcPtr crtc);
+ xf86RotateDestroy(xf86CrtcPtr crtc);
 
 /*
  * free shadow memory allocated for all crtcs
  */
 extern _X_EXPORT void
-xf86RotateFreeShadow(ScrnInfoPtr pScrn);
+ xf86RotateFreeShadow(ScrnInfoPtr pScrn);
 
 /*
  * Clean up rotation during CloseScreen
  */
 extern _X_EXPORT void
-xf86RotateCloseScreen (ScreenPtr pScreen);
+ xf86RotateCloseScreen(ScreenPtr pScreen);
 
 /**
  * Return whether any output is assigned to the crtc
  */
 extern _X_EXPORT Bool
-xf86CrtcInUse (xf86CrtcPtr crtc);
+ xf86CrtcInUse(xf86CrtcPtr crtc);
 
 /*
  * Output functions
  */
 extern _X_EXPORT xf86OutputPtr
-xf86OutputCreate (ScrnInfoPtr		    scrn,
-		  const xf86OutputFuncsRec  *funcs,
-		  const char		    *name);
+xf86OutputCreate(ScrnInfoPtr scrn,
+                 const xf86OutputFuncsRec * funcs, const char *name);
 
 extern _X_EXPORT void
-xf86OutputUseScreenMonitor (xf86OutputPtr output, Bool use_screen_monitor);
+ xf86OutputUseScreenMonitor(xf86OutputPtr output, Bool use_screen_monitor);
 
 extern _X_EXPORT Bool
-xf86OutputRename (xf86OutputPtr output, const char *name);
+ xf86OutputRename(xf86OutputPtr output, const char *name);
 
 extern _X_EXPORT void
-xf86OutputDestroy (xf86OutputPtr	output);
+ xf86OutputDestroy(xf86OutputPtr output);
 
 extern _X_EXPORT void
-xf86ProbeOutputModes (ScrnInfoPtr pScrn, int maxX, int maxY);
+ xf86ProbeOutputModes(ScrnInfoPtr pScrn, int maxX, int maxY);
 
 extern _X_EXPORT void
-xf86SetScrnInfoModes (ScrnInfoPtr pScrn);
+ xf86SetScrnInfoModes(ScrnInfoPtr pScrn);
 
 #ifdef RANDR_13_INTERFACE
-# define ScreenInitRetType	int
+#define ScreenInitRetType	int
 #else
-# define ScreenInitRetType	Bool
+#define ScreenInitRetType	Bool
 #endif
 
-extern _X_EXPORT ScreenInitRetType
-xf86CrtcScreenInit (ScreenPtr pScreen);
+extern _X_EXPORT ScreenInitRetType xf86CrtcScreenInit(ScreenPtr pScreen);
 
 extern _X_EXPORT Bool
-xf86InitialConfiguration (ScrnInfoPtr pScrn, Bool canGrow);
+ xf86InitialConfiguration(ScrnInfoPtr pScrn, Bool canGrow);
 
 extern _X_EXPORT void
-xf86DPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags);
-    
+ xf86DPMSSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags);
+
 extern _X_EXPORT Bool
-xf86SaveScreen(ScreenPtr pScreen, int mode);
+ xf86SaveScreen(ScreenPtr pScreen, int mode);
 
 extern _X_EXPORT void
-xf86DisableUnusedFunctions(ScrnInfoPtr pScrn);
+ xf86DisableUnusedFunctions(ScrnInfoPtr pScrn);
 
 extern _X_EXPORT DisplayModePtr
-xf86OutputFindClosestMode (xf86OutputPtr output, DisplayModePtr desired);
-    
+xf86OutputFindClosestMode(xf86OutputPtr output, DisplayModePtr desired);
+
 extern _X_EXPORT Bool
-xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation);
+
+xf86SetSingleMode(ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation);
 
 /**
  * Set the EDID information for the specified output
  */
 extern _X_EXPORT void
-xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon);
+ xf86OutputSetEDID(xf86OutputPtr output, xf86MonPtr edid_mon);
 
 /**
  * Return the list of modes supported by the EDID information
  * stored in 'output'
  */
-extern _X_EXPORT DisplayModePtr
-xf86OutputGetEDIDModes (xf86OutputPtr output);
+extern _X_EXPORT DisplayModePtr xf86OutputGetEDIDModes(xf86OutputPtr output);
 
 extern _X_EXPORT xf86MonPtr
-xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus);
+xf86OutputGetEDID(xf86OutputPtr output, I2CBusPtr pDDCBus);
 
 /**
  * Initialize dga for this screen
@@ -871,23 +855,23 @@ xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus);
 
 #ifdef XFreeXDGA
 extern _X_EXPORT Bool
-xf86DiDGAInit (ScreenPtr pScreen, unsigned long dga_address);
+ xf86DiDGAInit(ScreenPtr pScreen, unsigned long dga_address);
 
 /* this is the real function, used only internally */
 _X_INTERNAL Bool
-_xf86_di_dga_init_internal (ScreenPtr pScreen);
+ _xf86_di_dga_init_internal(ScreenPtr pScreen);
 
 /**
  * Re-initialize dga for this screen (as when the set of modes changes)
  */
 
 extern _X_EXPORT Bool
-xf86DiDGAReInit (ScreenPtr pScreen);
+ xf86DiDGAReInit(ScreenPtr pScreen);
 #endif
 
 /* This is the real function, used only internally */
 _X_INTERNAL Bool
-_xf86_di_dga_reinit_internal (ScreenPtr pScreen);
+ _xf86_di_dga_reinit_internal(ScreenPtr pScreen);
 
 /*
  * Set the subpixel order reported for the screen using
@@ -895,13 +879,12 @@ _xf86_di_dga_reinit_internal (ScreenPtr pScreen);
  */
 
 extern _X_EXPORT void
-xf86CrtcSetScreenSubpixelOrder (ScreenPtr pScreen);
+ xf86CrtcSetScreenSubpixelOrder(ScreenPtr pScreen);
 
 /*
  * Get a standard string name for a connector type 
  */
-extern _X_EXPORT const char *
-xf86ConnectorGetName(xf86ConnectorType connector);
+extern _X_EXPORT const char *xf86ConnectorGetName(xf86ConnectorType connector);
 
 /*
  * Using the desired mode information in each crtc, set
@@ -909,7 +892,7 @@ xf86ConnectorGetName(xf86ConnectorType connector);
  */
 
 extern _X_EXPORT Bool
-xf86SetDesiredModes (ScrnInfoPtr pScrn);
+ xf86SetDesiredModes(ScrnInfoPtr pScrn);
 
 /**
  * Initialize the CRTC-based cursor code. CRTC function vectors must
@@ -918,7 +901,7 @@ xf86SetDesiredModes (ScrnInfoPtr pScrn);
  * Driver should call this from ScreenInit function
  */
 extern _X_EXPORT Bool
-xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags);
+ xf86_cursors_init(ScreenPtr screen, int max_width, int max_height, int flags);
 
 /**
  * Called when anything on the screen is reconfigured.
@@ -928,25 +911,25 @@ xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags);
  * Driver should call this from crtc commit function.
  */
 extern _X_EXPORT void
-xf86_reload_cursors (ScreenPtr screen);
+ xf86_reload_cursors(ScreenPtr screen);
 
 /**
  * Called from EnterVT to turn the cursors back on
  */
 extern _X_EXPORT void
-xf86_show_cursors (ScrnInfoPtr scrn);
+ xf86_show_cursors(ScrnInfoPtr scrn);
 
 /**
  * Called by the driver to turn cursors off
  */
 extern _X_EXPORT void
-xf86_hide_cursors (ScrnInfoPtr scrn);
+ xf86_hide_cursors(ScrnInfoPtr scrn);
 
 /**
  * Clean up CRTC-based cursor code. Driver must call this at CloseScreen time.
  */
 extern _X_EXPORT void
-xf86_cursors_fini (ScreenPtr screen);
+ xf86_cursors_fini(ScreenPtr screen);
 
 /**
  * Transform the cursor's coordinates based on the crtc transform.  Normally
@@ -954,7 +937,7 @@ xf86_cursors_fini (ScreenPtr screen);
  * then the server does not transform the cursor position automatically.
  */
 extern _X_EXPORT void
-xf86CrtcTransformCursorPos (xf86CrtcPtr crtc, int *x, int *y);
+ xf86CrtcTransformCursorPos(xf86CrtcPtr crtc, int *x, int *y);
 
 #ifdef XV
 /*
@@ -964,33 +947,32 @@ xf86CrtcTransformCursorPos (xf86CrtcPtr crtc, int *x, int *y);
  */
 
 extern _X_EXPORT Bool
+
 xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,
-			    xf86CrtcPtr *crtc_ret,
-			    xf86CrtcPtr desired_crtc,
-			    BoxPtr      dst,
-			    INT32	*xa,
-			    INT32	*xb,
-			    INT32	*ya,
-			    INT32	*yb,
-			    RegionPtr   reg,
-			    INT32	width,
-			    INT32	height);
+                            xf86CrtcPtr * crtc_ret,
+                            xf86CrtcPtr desired_crtc,
+                            BoxPtr dst,
+                            INT32 *xa,
+                            INT32 *xb,
+                            INT32 *ya,
+                            INT32 *yb,
+                            RegionPtr reg, INT32 width, INT32 height);
 #endif
-    
+
 extern _X_EXPORT xf86_crtc_notify_proc_ptr
-xf86_wrap_crtc_notify (ScreenPtr pScreen, xf86_crtc_notify_proc_ptr new);
+xf86_wrap_crtc_notify(ScreenPtr pScreen, xf86_crtc_notify_proc_ptr new);
 
 extern _X_EXPORT void
-xf86_unwrap_crtc_notify(ScreenPtr pScreen, xf86_crtc_notify_proc_ptr old);
+ xf86_unwrap_crtc_notify(ScreenPtr pScreen, xf86_crtc_notify_proc_ptr old);
 
 extern _X_EXPORT void
-xf86_crtc_notify(ScreenPtr pScreen);
+ xf86_crtc_notify(ScreenPtr pScreen);
 
 /**
  * Gamma
  */
 
 extern _X_EXPORT Bool
-xf86_crtc_supports_gamma(ScrnInfoPtr pScrn);
+ xf86_crtc_supports_gamma(ScrnInfoPtr pScrn);
 
-#endif /* _XF86CRTC_H_ */
+#endif                          /* _XF86CRTC_H_ */
diff --git a/xorg-server/hw/xfree86/modes/xf86Cursors.c b/xorg-server/hw/xfree86/modes/xf86Cursors.c
index 669da0d5b..95a78921d 100644
--- a/xorg-server/hw/xfree86/modes/xf86Cursors.c
+++ b/xorg-server/hw/xfree86/modes/xf86Cursors.c
@@ -52,10 +52,10 @@
  * that it's handling the screen transform, then this returns RR_Rotate_0.
  */
 static Rotation
-xf86_crtc_cursor_rotation (xf86CrtcPtr crtc)
+xf86_crtc_cursor_rotation(xf86CrtcPtr crtc)
 {
     if (crtc->driverIsPerformingTransform)
-	return RR_Rotate_0;
+        return RR_Rotate_0;
     return crtc->rotation;
 }
 
@@ -63,38 +63,34 @@ xf86_crtc_cursor_rotation (xf86CrtcPtr crtc)
  * Given a screen coordinate, rotate back to a cursor source coordinate
  */
 static void
-xf86_crtc_rotate_coord (Rotation    rotation,
-			int	    width,
-			int	    height,
-			int	    x_dst,
-			int	    y_dst,
-			int	    *x_src,
-			int	    *y_src)
+xf86_crtc_rotate_coord(Rotation rotation,
+                       int width,
+                       int height, int x_dst, int y_dst, int *x_src, int *y_src)
 {
     int t;
-    
+
     switch (rotation & 0xf) {
     case RR_Rotate_0:
-	break;
+        break;
     case RR_Rotate_90:
-	t = x_dst;
-	x_dst = height - y_dst - 1;
-	y_dst = t;
-	break;
+        t = x_dst;
+        x_dst = height - y_dst - 1;
+        y_dst = t;
+        break;
     case RR_Rotate_180:
-	x_dst = width - x_dst - 1;
-	y_dst = height - y_dst - 1;
-	break;
+        x_dst = width - x_dst - 1;
+        y_dst = height - y_dst - 1;
+        break;
     case RR_Rotate_270:
-	t = x_dst;
-	x_dst = y_dst;
-	y_dst = width - t - 1;
-	break;
+        t = x_dst;
+        x_dst = y_dst;
+        y_dst = width - t - 1;
+        break;
     }
     if (rotation & RR_Reflect_X)
-	x_dst = width - x_dst - 1;
+        x_dst = width - x_dst - 1;
     if (rotation & RR_Reflect_Y)
-	y_dst = height - y_dst - 1;
+        y_dst = height - y_dst - 1;
     *x_src = x_dst;
     *y_src = y_dst;
 }
@@ -103,38 +99,35 @@ xf86_crtc_rotate_coord (Rotation    rotation,
  * Given a cursor source  coordinate, rotate to a screen coordinate
  */
 static void
-xf86_crtc_rotate_coord_back (Rotation    rotation,
-			     int	    width,
-			     int	    height,
-			     int	    x_dst,
-			     int	    y_dst,
-			     int	    *x_src,
-			     int	    *y_src)
+xf86_crtc_rotate_coord_back(Rotation rotation,
+                            int width,
+                            int height,
+                            int x_dst, int y_dst, int *x_src, int *y_src)
 {
     int t;
-    
+
     if (rotation & RR_Reflect_X)
-	x_dst = width - x_dst - 1;
+        x_dst = width - x_dst - 1;
     if (rotation & RR_Reflect_Y)
-	y_dst = height - y_dst - 1;
+        y_dst = height - y_dst - 1;
 
     switch (rotation & 0xf) {
     case RR_Rotate_0:
-	break;
+        break;
     case RR_Rotate_90:
-	t = x_dst;
-	x_dst = y_dst;
-	y_dst = width - t - 1;
-	break;
+        t = x_dst;
+        x_dst = y_dst;
+        y_dst = width - t - 1;
+        break;
     case RR_Rotate_180:
-	x_dst = width - x_dst - 1;
-	y_dst = height - y_dst - 1;
-	break;
+        x_dst = width - x_dst - 1;
+        y_dst = height - y_dst - 1;
+        break;
     case RR_Rotate_270:
-	t = x_dst;
-	x_dst = height - y_dst - 1;
-	y_dst = t;
-	break;
+        t = x_dst;
+        x_dst = height - y_dst - 1;
+        y_dst = t;
+        break;
     }
     *x_src = x_dst;
     *y_src = y_dst;
@@ -149,16 +142,16 @@ struct cursor_bit {
  * Convert an x coordinate to a position within the cursor bitmap
  */
 static struct cursor_bit
-cursor_bitpos (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y,
-	       Bool mask)
+cursor_bitpos(CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y,
+              Bool mask)
 {
     const int flags = cursor_info->Flags;
     const Bool interleaved =
-	!!(flags & (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1 |
-		    HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8 |
-		    HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16 |
-		    HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32 |
-		    HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64));
+        ! !(flags & (HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1 |
+                     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8 |
+                     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16 |
+                     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32 |
+                     HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64));
     const int width = cursor_info->MaxWidth;
     const int height = cursor_info->MaxHeight;
     const int stride = interleaved ? width / 4 : width / 8;
@@ -168,24 +161,24 @@ cursor_bitpos (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y,
     image += y * stride;
 
     if (flags & HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK)
-	mask = !mask;
+        mask = !mask;
     if (flags & HARDWARE_CURSOR_NIBBLE_SWAPPED)
-	x = (x & ~3) | (3 - (x & 3));
+        x = (x & ~3) | (3 - (x & 3));
     if (((flags & HARDWARE_CURSOR_BIT_ORDER_MSBFIRST) == 0) ==
-	(X_BYTE_ORDER == X_BIG_ENDIAN))
-	x = (x & ~7) | (7 - (x & 7));
+        (X_BYTE_ORDER == X_BIG_ENDIAN))
+        x = (x & ~7) | (7 - (x & 7));
     if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1)
-	x = (x << 1) + mask;
+        x = (x << 1) + mask;
     else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8)
-	x = ((x & ~7) << 1) | (mask << 3) | (x & 7);
+        x = ((x & ~7) << 1) | (mask << 3) | (x & 7);
     else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16)
-	x = ((x & ~15) << 1) | (mask << 4) | (x & 15);
+        x = ((x & ~15) << 1) | (mask << 4) | (x & 15);
     else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32)
-	x = ((x & ~31) << 1) | (mask << 5) | (x & 31);
+        x = ((x & ~31) << 1) | (mask << 5) | (x & 31);
     else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64)
-	x = ((x & ~63) << 1) | (mask << 6) | (x & 63);
+        x = ((x & ~63) << 1) | (mask << 6) | (x & 63);
     else if (mask)
-	image += stride * height;
+        image += stride * height;
 
     ret.byte = image + (x / 8);
     ret.bitpos = x & 7;
@@ -197,9 +190,10 @@ cursor_bitpos (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y,
  * Fetch one bit from a cursor bitmap
  */
 static CARD8
-get_bit (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y, Bool mask)
+get_bit(CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y, Bool mask)
 {
     struct cursor_bit bit = cursor_bitpos(image, cursor_info, x, y, mask);
+
     return (*bit.byte >> bit.bitpos) & 1;
 }
 
@@ -207,185 +201,177 @@ get_bit (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y, Bool mask)
  * Set one bit in a cursor bitmap
  */
 static void
-set_bit (CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y, Bool mask)
+set_bit(CARD8 *image, xf86CursorInfoPtr cursor_info, int x, int y, Bool mask)
 {
     struct cursor_bit bit = cursor_bitpos(image, cursor_info, x, y, mask);
+
     *bit.byte |= 1 << bit.bitpos;
 }
-    
+
 /*
  * Load a two color cursor into a driver that supports only ARGB cursors
  */
 static void
-xf86_crtc_convert_cursor_to_argb (xf86CrtcPtr crtc, unsigned char *src)
+xf86_crtc_convert_cursor_to_argb(xf86CrtcPtr crtc, unsigned char *src)
 {
-    ScrnInfoPtr		scrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-    CARD32		*cursor_image = (CARD32 *) xf86_config->cursor_image;
-    int			x, y;
-    int			xin, yin;
-    int			flags = cursor_info->Flags;
-    CARD32		bits;
-    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
+    ScrnInfoPtr scrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+    CARD32 *cursor_image = (CARD32 *) xf86_config->cursor_image;
+    int x, y;
+    int xin, yin;
+    int flags = cursor_info->Flags;
+    CARD32 bits;
+    const Rotation rotation = xf86_crtc_cursor_rotation(crtc);
 
 #ifdef ARGB_CURSOR
     crtc->cursor_argb = FALSE;
 #endif
 
     for (y = 0; y < cursor_info->MaxHeight; y++)
-	for (x = 0; x < cursor_info->MaxWidth; x++) 
-	{
-	    xf86_crtc_rotate_coord (rotation,
-				    cursor_info->MaxWidth,
-				    cursor_info->MaxHeight,
-				    x, y, &xin, &yin);
-	    if (get_bit (src, cursor_info, xin, yin, TRUE) ==
-		((flags & HARDWARE_CURSOR_INVERT_MASK) == 0))
-	    {
-		if (get_bit (src, cursor_info, xin, yin, FALSE))
-		    bits = xf86_config->cursor_fg;
-		else
-		    bits = xf86_config->cursor_bg;
-	    }
-	    else
-		bits = 0;
-	    cursor_image[y * cursor_info->MaxWidth + x] = bits;
-	}
-    crtc->funcs->load_cursor_argb (crtc, cursor_image);
+        for (x = 0; x < cursor_info->MaxWidth; x++) {
+            xf86_crtc_rotate_coord(rotation,
+                                   cursor_info->MaxWidth,
+                                   cursor_info->MaxHeight, x, y, &xin, &yin);
+            if (get_bit(src, cursor_info, xin, yin, TRUE) ==
+                ((flags & HARDWARE_CURSOR_INVERT_MASK) == 0)) {
+                if (get_bit(src, cursor_info, xin, yin, FALSE))
+                    bits = xf86_config->cursor_fg;
+                else
+                    bits = xf86_config->cursor_bg;
+            }
+            else
+                bits = 0;
+            cursor_image[y * cursor_info->MaxWidth + x] = bits;
+        }
+    crtc->funcs->load_cursor_argb(crtc, cursor_image);
 }
 
 /*
  * Set the colors for a two-color cursor (ignore for ARGB cursors)
  */
 static void
-xf86_set_cursor_colors (ScrnInfoPtr scrn, int bg, int fg)
+xf86_set_cursor_colors(ScrnInfoPtr scrn, int bg, int fg)
 {
-    ScreenPtr		screen = scrn->pScreen;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    CursorPtr		cursor = xf86_config->cursor;
-    int			c;
-    CARD8		*bits = cursor ?
+    ScreenPtr screen = scrn->pScreen;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    CursorPtr cursor = xf86_config->cursor;
+    int c;
+    CARD8 *bits = cursor ?
         dixLookupScreenPrivate(&cursor->devPrivates, CursorScreenKey, screen)
-      : NULL;
+        : NULL;
 
     /* Save ARGB versions of these colors */
     xf86_config->cursor_fg = (CARD32) fg | 0xff000000;
     xf86_config->cursor_bg = (CARD32) bg | 0xff000000;
-    
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
-
-	if (crtc->enabled && !crtc->cursor_argb)
-	{
-	    if (crtc->funcs->load_cursor_image)
-		crtc->funcs->set_cursor_colors (crtc, bg, fg);
-	    else if (bits)
-		xf86_crtc_convert_cursor_to_argb (crtc, bits);
-	}
+
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+        if (crtc->enabled && !crtc->cursor_argb) {
+            if (crtc->funcs->load_cursor_image)
+                crtc->funcs->set_cursor_colors(crtc, bg, fg);
+            else if (bits)
+                xf86_crtc_convert_cursor_to_argb(crtc, bits);
+        }
     }
 }
 
 static void
-xf86_crtc_hide_cursor (xf86CrtcPtr crtc)
+xf86_crtc_hide_cursor(xf86CrtcPtr crtc)
 {
-    if (crtc->cursor_shown)
-    {
-	crtc->funcs->hide_cursor (crtc);
-	crtc->cursor_shown = FALSE;
+    if (crtc->cursor_shown) {
+        crtc->funcs->hide_cursor(crtc);
+        crtc->cursor_shown = FALSE;
     }
 }
 
 void
-xf86_hide_cursors (ScrnInfoPtr scrn)
+xf86_hide_cursors(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     xf86_config->cursor_on = FALSE;
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (crtc->enabled)
-	    xf86_crtc_hide_cursor (crtc);
+        if (crtc->enabled)
+            xf86_crtc_hide_cursor(crtc);
     }
 }
-    
+
 static void
-xf86_crtc_show_cursor (xf86CrtcPtr crtc)
+xf86_crtc_show_cursor(xf86CrtcPtr crtc)
 {
-    if (!crtc->cursor_shown && crtc->cursor_in_range)
-    {
-	crtc->funcs->show_cursor (crtc);
-	crtc->cursor_shown = TRUE;
+    if (!crtc->cursor_shown && crtc->cursor_in_range) {
+        crtc->funcs->show_cursor(crtc);
+        crtc->cursor_shown = TRUE;
     }
 }
 
 void
-xf86_show_cursors (ScrnInfoPtr scrn)
+xf86_show_cursors(ScrnInfoPtr scrn)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     xf86_config->cursor_on = TRUE;
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (crtc->enabled)
-	    xf86_crtc_show_cursor (crtc);
+        if (crtc->enabled)
+            xf86_crtc_show_cursor(crtc);
     }
 }
 
-void xf86CrtcTransformCursorPos (xf86CrtcPtr crtc, int *x, int *y)
+void
+xf86CrtcTransformCursorPos(xf86CrtcPtr crtc, int *x, int *y)
 {
     ScrnInfoPtr scrn = crtc->scrn;
     ScreenPtr screen = scrn->pScreen;
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
     xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
     xf86CursorScreenPtr ScreenPriv =
-	(xf86CursorScreenPtr)dixLookupPrivate(&screen->devPrivates,
-					      xf86CursorScreenKey);
+        (xf86CursorScreenPtr) dixLookupPrivate(&screen->devPrivates,
+                                               xf86CursorScreenKey);
     struct pict_f_vector v;
     int dx, dy;
 
     v.v[0] = (*x + ScreenPriv->HotX) + 0.5;
     v.v[1] = (*y + ScreenPriv->HotY) + 0.5;
     v.v[2] = 1;
-    pixman_f_transform_point (&crtc->f_framebuffer_to_crtc, &v);
+    pixman_f_transform_point(&crtc->f_framebuffer_to_crtc, &v);
     /* cursor will have 0.5 added to it already so floor is sufficent */
-    *x = floor (v.v[0]);
-    *y = floor (v.v[1]);
+    *x = floor(v.v[0]);
+    *y = floor(v.v[1]);
     /*
      * Transform position of cursor upper left corner
      */
-    xf86_crtc_rotate_coord_back (crtc->rotation, cursor_info->MaxWidth,
-				 cursor_info->MaxHeight, ScreenPriv->HotX,
-				 ScreenPriv->HotY, &dx, &dy);
+    xf86_crtc_rotate_coord_back(crtc->rotation, cursor_info->MaxWidth,
+                                cursor_info->MaxHeight, ScreenPriv->HotX,
+                                ScreenPriv->HotY, &dx, &dy);
     *x -= dx;
     *y -= dy;
 }
 
 static void
-xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
+xf86_crtc_set_cursor_position(xf86CrtcPtr crtc, int x, int y)
 {
-    ScrnInfoPtr		scrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-    DisplayModePtr	mode = &crtc->mode;
-    Bool		in_range;
+    ScrnInfoPtr scrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+    DisplayModePtr mode = &crtc->mode;
+    Bool in_range;
 
     /*
      * Transform position of cursor on screen
      */
     if (crtc->transform_in_use && !crtc->driverIsPerformingTransform)
-	xf86CrtcTransformCursorPos(crtc, &x, &y);
-    else
-    {
-	x -= crtc->x;
-	y -= crtc->y;
+        xf86CrtcTransformCursorPos(crtc, &x, &y);
+    else {
+        x -= crtc->x;
+        y -= crtc->y;
     }
 
     /*
@@ -393,216 +379,206 @@ xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
      */
     in_range = TRUE;
     if (x >= mode->HDisplay || y >= mode->VDisplay ||
-	x <= -cursor_info->MaxWidth || y <= -cursor_info->MaxHeight) 
-    {
-	in_range = FALSE;
-	x = 0;
-	y = 0;
+        x <= -cursor_info->MaxWidth || y <= -cursor_info->MaxHeight) {
+        in_range = FALSE;
+        x = 0;
+        y = 0;
     }
 
     crtc->cursor_in_range = in_range;
-    
-    if (in_range)
-    {
-	crtc->funcs->set_cursor_position (crtc, x, y);
-	xf86_crtc_show_cursor (crtc);
+
+    if (in_range) {
+        crtc->funcs->set_cursor_position(crtc, x, y);
+        xf86_crtc_show_cursor(crtc);
     }
     else
-	xf86_crtc_hide_cursor (crtc);
+        xf86_crtc_hide_cursor(crtc);
 }
 
 static void
-xf86_set_cursor_position (ScrnInfoPtr scrn, int x, int y)
+xf86_set_cursor_position(ScrnInfoPtr scrn, int x, int y)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     /* undo what xf86HWCurs did to the coordinates */
     x += scrn->frameX0;
     y += scrn->frameY0;
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (crtc->enabled)
-	    xf86_crtc_set_cursor_position (crtc, x, y);
+        if (crtc->enabled)
+            xf86_crtc_set_cursor_position(crtc, x, y);
     }
 }
-    
+
 /*
  * Load a two-color cursor into a crtc, performing rotation as needed
  */
 static void
-xf86_crtc_load_cursor_image (xf86CrtcPtr crtc, CARD8 *src)
+xf86_crtc_load_cursor_image(xf86CrtcPtr crtc, CARD8 *src)
 {
-    ScrnInfoPtr		scrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-    CARD8		*cursor_image;
-    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
+    ScrnInfoPtr scrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+    CARD8 *cursor_image;
+    const Rotation rotation = xf86_crtc_cursor_rotation(crtc);
 
 #ifdef ARGB_CURSOR
     crtc->cursor_argb = FALSE;
 #endif
 
     if (rotation == RR_Rotate_0)
-	cursor_image = src;
-    else
-    {
+        cursor_image = src;
+    else {
         int x, y;
-    	int xin, yin;
-	int stride = cursor_info->MaxWidth >> 2;
-	
-	cursor_image = xf86_config->cursor_image;
-	memset(cursor_image, 0, cursor_info->MaxHeight * stride);
-	
+        int xin, yin;
+        int stride = cursor_info->MaxWidth >> 2;
+
+        cursor_image = xf86_config->cursor_image;
+        memset(cursor_image, 0, cursor_info->MaxHeight * stride);
+
         for (y = 0; y < cursor_info->MaxHeight; y++)
-	    for (x = 0; x < cursor_info->MaxWidth; x++) 
-	    {
-		xf86_crtc_rotate_coord (rotation,
-					cursor_info->MaxWidth,
-					cursor_info->MaxHeight,
-					x, y, &xin, &yin);
-		if (get_bit(src, cursor_info, xin, yin, FALSE))
-		    set_bit(cursor_image, cursor_info, x, y, FALSE);
-		if (get_bit(src, cursor_info, xin, yin, TRUE))
-		    set_bit(cursor_image, cursor_info, x, y, TRUE);
-	    }
+            for (x = 0; x < cursor_info->MaxWidth; x++) {
+                xf86_crtc_rotate_coord(rotation,
+                                       cursor_info->MaxWidth,
+                                       cursor_info->MaxHeight,
+                                       x, y, &xin, &yin);
+                if (get_bit(src, cursor_info, xin, yin, FALSE))
+                    set_bit(cursor_image, cursor_info, x, y, FALSE);
+                if (get_bit(src, cursor_info, xin, yin, TRUE))
+                    set_bit(cursor_image, cursor_info, x, y, TRUE);
+            }
     }
-    crtc->funcs->load_cursor_image (crtc, cursor_image);
+    crtc->funcs->load_cursor_image(crtc, cursor_image);
 }
-    
+
 /*
  * Load a cursor image into all active CRTCs
  */
 static void
-xf86_load_cursor_image (ScrnInfoPtr scrn, unsigned char *src)
+xf86_load_cursor_image(ScrnInfoPtr scrn, unsigned char *src)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
-
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
-
-	if (crtc->enabled)
-	{
-	    if (crtc->funcs->load_cursor_image)
-		xf86_crtc_load_cursor_image (crtc, src);
-	    else if (crtc->funcs->load_cursor_argb)
-		xf86_crtc_convert_cursor_to_argb (crtc, src);
-	}
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
+
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+        if (crtc->enabled) {
+            if (crtc->funcs->load_cursor_image)
+                xf86_crtc_load_cursor_image(crtc, src);
+            else if (crtc->funcs->load_cursor_argb)
+                xf86_crtc_convert_cursor_to_argb(crtc, src);
+        }
     }
 }
 
 static Bool
-xf86_use_hw_cursor (ScreenPtr screen, CursorPtr cursor)
+xf86_use_hw_cursor(ScreenPtr screen, CursorPtr cursor)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
 
     ++cursor->refcnt;
     if (xf86_config->cursor)
-	FreeCursor (xf86_config->cursor, None);
+        FreeCursor(xf86_config->cursor, None);
     xf86_config->cursor = cursor;
 
     if (cursor->bits->width > cursor_info->MaxWidth ||
-	cursor->bits->height> cursor_info->MaxHeight)
-	return FALSE;
+        cursor->bits->height > cursor_info->MaxHeight)
+        return FALSE;
 
     return TRUE;
 }
 
 static Bool
-xf86_use_hw_cursor_argb (ScreenPtr screen, CursorPtr cursor)
+xf86_use_hw_cursor_argb(ScreenPtr screen, CursorPtr cursor)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-    
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+
     ++cursor->refcnt;
     if (xf86_config->cursor)
-	FreeCursor (xf86_config->cursor, None);
+        FreeCursor(xf86_config->cursor, None);
     xf86_config->cursor = cursor;
-    
+
     /* Make sure ARGB support is available */
     if ((cursor_info->Flags & HARDWARE_CURSOR_ARGB) == 0)
-	return FALSE;
-    
+        return FALSE;
+
     if (cursor->bits->width > cursor_info->MaxWidth ||
-	cursor->bits->height> cursor_info->MaxHeight)
-	return FALSE;
+        cursor->bits->height > cursor_info->MaxHeight)
+        return FALSE;
 
     return TRUE;
 }
 
 static void
-xf86_crtc_load_cursor_argb (xf86CrtcPtr crtc, CursorPtr cursor)
+xf86_crtc_load_cursor_argb(xf86CrtcPtr crtc, CursorPtr cursor)
 {
-    ScrnInfoPtr		scrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-    CARD32		*cursor_image = (CARD32 *) xf86_config->cursor_image;
-    CARD32		*cursor_source = (CARD32 *) cursor->bits->argb;
-    int			x, y;
-    int			xin, yin;
-    CARD32		bits;
-    int			source_width = cursor->bits->width;
-    int			source_height = cursor->bits->height;
-    int			image_width = cursor_info->MaxWidth;
-    int			image_height = cursor_info->MaxHeight;
-    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
+    ScrnInfoPtr scrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+    CARD32 *cursor_image = (CARD32 *) xf86_config->cursor_image;
+    CARD32 *cursor_source = (CARD32 *) cursor->bits->argb;
+    int x, y;
+    int xin, yin;
+    CARD32 bits;
+    int source_width = cursor->bits->width;
+    int source_height = cursor->bits->height;
+    int image_width = cursor_info->MaxWidth;
+    int image_height = cursor_info->MaxHeight;
+    const Rotation rotation = xf86_crtc_cursor_rotation(crtc);
 
     for (y = 0; y < image_height; y++)
-	for (x = 0; x < image_width; x++)
-	{
-	    xf86_crtc_rotate_coord (rotation, image_width, image_height, x, y,
-				    &xin, &yin);
-	    if (xin < source_width && yin < source_height)
-		bits = cursor_source[yin * source_width + xin];
-	    else
-		bits = 0;
-	    cursor_image[y * image_width + x] = bits;
-	}
-    
-    crtc->funcs->load_cursor_argb (crtc, cursor_image);
+        for (x = 0; x < image_width; x++) {
+            xf86_crtc_rotate_coord(rotation, image_width, image_height, x, y,
+                                   &xin, &yin);
+            if (xin < source_width && yin < source_height)
+                bits = cursor_source[yin * source_width + xin];
+            else
+                bits = 0;
+            cursor_image[y * image_width + x] = bits;
+        }
+
+    crtc->funcs->load_cursor_argb(crtc, cursor_image);
 }
 
 static void
-xf86_load_cursor_argb (ScrnInfoPtr scrn, CursorPtr cursor)
+xf86_load_cursor_argb(ScrnInfoPtr scrn, CursorPtr cursor)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (crtc->enabled)
-	    xf86_crtc_load_cursor_argb (crtc, cursor);
+        if (crtc->enabled)
+            xf86_crtc_load_cursor_argb(crtc, cursor);
     }
 }
 
 Bool
-xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags)
+xf86_cursors_init(ScreenPtr screen, int max_width, int max_height, int flags)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    xf86CursorInfoPtr	cursor_info;
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info;
 
     cursor_info = xf86CreateCursorInfoRec();
     if (!cursor_info)
-	return FALSE;
+        return FALSE;
 
     xf86_config->cursor_image = malloc(max_width * max_height * 4);
 
-    if (!xf86_config->cursor_image)
-    {
-	xf86DestroyCursorInfoRec (cursor_info);
-	return FALSE;
+    if (!xf86_config->cursor_image) {
+        xf86DestroyCursorInfoRec(cursor_info);
+        return FALSE;
     }
-	
+
     xf86_config->cursor_info = cursor_info;
 
     cursor_info->MaxWidth = max_width;
@@ -616,17 +592,16 @@ xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags)
     cursor_info->ShowCursor = xf86_show_cursors;
     cursor_info->UseHWCursor = xf86_use_hw_cursor;
 #ifdef ARGB_CURSOR
-    if (flags & HARDWARE_CURSOR_ARGB)
-    {
-	cursor_info->UseHWCursorARGB = xf86_use_hw_cursor_argb;
-	cursor_info->LoadCursorARGB = xf86_load_cursor_argb;
+    if (flags & HARDWARE_CURSOR_ARGB) {
+        cursor_info->UseHWCursorARGB = xf86_use_hw_cursor_argb;
+        cursor_info->LoadCursorARGB = xf86_load_cursor_argb;
     }
 #endif
-    
+
     xf86_config->cursor = NULL;
-    xf86_hide_cursors (scrn);
-    
-    return xf86InitCursor (screen, cursor_info);
+    xf86_hide_cursors(scrn);
+
+    return xf86InitCursor(screen, cursor_info);
 }
 
 /**
@@ -636,25 +611,25 @@ xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags)
  */
 
 void
-xf86_reload_cursors (ScreenPtr screen)
+xf86_reload_cursors(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn;
-    xf86CrtcConfigPtr   xf86_config;
-    xf86CursorInfoPtr   cursor_info;
-    CursorPtr		cursor;
-    int			x, y;
+    ScrnInfoPtr scrn;
+    xf86CrtcConfigPtr xf86_config;
+    xf86CursorInfoPtr cursor_info;
+    CursorPtr cursor;
+    int x, y;
     xf86CursorScreenPtr cursor_screen_priv;
-    
+
     /* initial mode setting will not have set a screen yet.
        May be called before the devices are initialised.
      */
     if (!screen || !inputInfo.pointer)
-	return;
+        return;
     cursor_screen_priv = dixLookupPrivate(&screen->devPrivates,
-					  xf86CursorScreenKey);
+                                          xf86CursorScreenKey);
     /* return if HW cursor is inactive, to avoid displaying two cursors */
     if (!cursor_screen_priv || !cursor_screen_priv->isUp)
-	return;
+        return;
 
     scrn = xf86Screens[screen->myNum];
     xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
@@ -662,26 +637,27 @@ xf86_reload_cursors (ScreenPtr screen)
     /* make sure the cursor code has been initialized */
     cursor_info = xf86_config->cursor_info;
     if (!cursor_info)
-	return;
+        return;
 
     cursor = xf86_config->cursor;
-    GetSpritePosition (inputInfo.pointer, &x, &y);
+    GetSpritePosition(inputInfo.pointer, &x, &y);
     if (!(cursor_info->Flags & HARDWARE_CURSOR_UPDATE_UNHIDDEN))
-	(*cursor_info->HideCursor)(scrn);
+        (*cursor_info->HideCursor) (scrn);
 
-    if (cursor)
-    {
-	void *src = dixLookupScreenPrivate(&cursor->devPrivates, CursorScreenKey, screen);
+    if (cursor) {
+        void *src =
+            dixLookupScreenPrivate(&cursor->devPrivates, CursorScreenKey,
+                                   screen);
 #ifdef ARGB_CURSOR
-	if (cursor->bits->argb && cursor_info->LoadCursorARGB)
-	    (*cursor_info->LoadCursorARGB) (scrn, cursor);
-	else if (src)
+        if (cursor->bits->argb && cursor_info->LoadCursorARGB)
+            (*cursor_info->LoadCursorARGB) (scrn, cursor);
+        else if (src)
 #endif
-	    (*cursor_info->LoadCursorImage)(scrn, src);
+            (*cursor_info->LoadCursorImage) (scrn, src);
 
-	x += scrn->frameX0 + cursor_screen_priv->HotX;
-	y += scrn->frameY0 + cursor_screen_priv->HotY;
-	(*cursor_info->SetCursorPosition)(scrn, x, y);
+        x += scrn->frameX0 + cursor_screen_priv->HotX;
+        y += scrn->frameY0 + cursor_screen_priv->HotY;
+        (*cursor_info->SetCursorPosition) (scrn, x, y);
     }
 }
 
@@ -689,21 +665,19 @@ xf86_reload_cursors (ScreenPtr screen)
  * Clean up CRTC-based cursor code
  */
 void
-xf86_cursors_fini (ScreenPtr screen)
+xf86_cursors_fini(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    
-    if (xf86_config->cursor_info)
-    {
-	xf86DestroyCursorInfoRec (xf86_config->cursor_info);
-	xf86_config->cursor_info = NULL;
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    if (xf86_config->cursor_info) {
+        xf86DestroyCursorInfoRec(xf86_config->cursor_info);
+        xf86_config->cursor_info = NULL;
     }
     free(xf86_config->cursor_image);
     xf86_config->cursor_image = NULL;
-    if (xf86_config->cursor)
-    {
-	FreeCursor (xf86_config->cursor, None);
-	xf86_config->cursor = NULL;
+    if (xf86_config->cursor) {
+        FreeCursor(xf86_config->cursor, None);
+        xf86_config->cursor = NULL;
     }
 }
diff --git a/xorg-server/hw/xfree86/modes/xf86DiDGA.c b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
index b2bbefa62..fafd95aed 100644
--- a/xorg-server/hw/xfree86/modes/xf86DiDGA.c
+++ b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
@@ -1,217 +1,214 @@
-/*

- * Copyright © 2006 Keith Packard

- *

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

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

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

- * notice and this permission notice appear in supporting documentation, and

- * that the name of the copyright holders not be used in advertising or

- * publicity pertaining to distribution of the software without specific,

- * written prior permission.  The copyright holders make no representations

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

- * is" without express or implied warranty.

- *

- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR

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

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

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

- * OF THIS SOFTWARE.

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#else

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#endif

-

-#include "xf86.h"

-#include "xf86DDC.h"

-#include "xf86_OSproc.h"

-#include "dgaproc.h"

-#include "xf86Crtc.h"

-#include "xf86Modes.h"

-#include "gcstruct.h"

-#include "scrnintstr.h"

-#include "windowstr.h"

-

-static Bool

-xf86_dga_get_modes (ScreenPtr pScreen)

-{

-    ScrnInfoPtr		scrn = xf86Screens[pScreen->myNum];

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    DGAModePtr		modes, mode;

-    DisplayModePtr	display_mode;

-    int			bpp = scrn->bitsPerPixel >> 3;

-    int			num;

-

-    num = 0;

-    display_mode = scrn->modes;

-    while (display_mode) 

-    {

-	num++;

-	display_mode = display_mode->next;

-	if (display_mode == scrn->modes)

-	    break;

-    }

-    

-    if (!num)

-	return FALSE;

-    

-    modes = malloc(num * sizeof(DGAModeRec));

-    if (!modes)

-	return FALSE;

-    

-    num = 0;

-    display_mode = scrn->modes;

-    while (display_mode) 

-    {

-	mode = modes + num++;

-

-	mode->mode = display_mode;

-	mode->flags = DGA_CONCURRENT_ACCESS;

-	if (display_mode->Flags & V_DBLSCAN)

-	    mode->flags |= DGA_DOUBLESCAN;

-	if (display_mode->Flags & V_INTERLACE)

-	    mode->flags |= DGA_INTERLACED;

-	mode->byteOrder = scrn->imageByteOrder;

-	mode->depth = scrn->depth;

-	mode->bitsPerPixel = scrn->bitsPerPixel;

-	mode->red_mask = scrn->mask.red;

-	mode->green_mask = scrn->mask.green;

-	mode->blue_mask = scrn->mask.blue;

-	mode->visualClass = (bpp == 1) ? PseudoColor : TrueColor;

-	mode->viewportWidth = display_mode->HDisplay;

-	mode->viewportHeight = display_mode->VDisplay;

-	mode->xViewportStep = (bpp == 3) ? 2 : 1;

-	mode->yViewportStep = 1;

-	mode->viewportFlags = DGA_FLIP_RETRACE;

-	mode->offset = 0;

-	mode->address = 0;

-	mode->imageWidth = mode->viewportWidth;

-	mode->imageHeight = mode->viewportHeight;

-	mode->bytesPerScanline = (mode->imageWidth * scrn->bitsPerPixel) >> 3;

-	mode->pixmapWidth = mode->imageWidth;

-	mode->pixmapHeight = mode->imageHeight;

-	mode->maxViewportX = 0;

-	mode->maxViewportY = 0;

-

-	display_mode = display_mode->next;

-	if (display_mode == scrn->modes)

-	    break;

-    }

-    free(xf86_config->dga_modes);

-    xf86_config->dga_nmode = num;

-    xf86_config->dga_modes = modes;

-    return TRUE;

-}

-

-static Bool

-xf86_dga_set_mode(ScrnInfoPtr scrn, DGAModePtr display_mode)

-{

-    ScreenPtr		pScreen = scrn->pScreen;

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-

-    if (!display_mode) 

-    {

-	if (xf86_config->dga_save_mode)

-	{

-	    xf86SwitchMode(pScreen, xf86_config->dga_save_mode);

-	    xf86_config->dga_save_mode = NULL;

-	}

-    }

-    else

-    {

-	if (!xf86_config->dga_save_mode)

-	{

-	    xf86_config->dga_save_mode = scrn->currentMode;

-	    xf86SwitchMode(pScreen, display_mode->mode);

-	}

-    }

-    return TRUE;

-}

-

-static int

-xf86_dga_get_viewport(ScrnInfoPtr scrn)

-{

-    return 0;

-}

-

-static void

-xf86_dga_set_viewport(ScrnInfoPtr scrn, int x, int y, int flags)

-{

-   scrn->AdjustFrame(scrn->pScreen->myNum, x, y, flags);

-}

-

-static Bool

-xf86_dga_open_framebuffer(ScrnInfoPtr scrn,

-			  char **name,

-			  unsigned char **mem, int *size, int *offset, int *flags)

-{

-    return FALSE;

-}

-

-static void

-xf86_dga_close_framebuffer(ScrnInfoPtr scrn)

-{

-}

-

-static DGAFunctionRec xf86_dga_funcs = {

-   xf86_dga_open_framebuffer,

-   xf86_dga_close_framebuffer,

-   xf86_dga_set_mode,

-   xf86_dga_set_viewport,

-   xf86_dga_get_viewport,

-   NULL,

-   NULL,

-   NULL,

-   NULL

-};

-

-Bool

-xf86DiDGAReInit (ScreenPtr pScreen)

-{

-    return TRUE;

-}

-

-Bool

-_xf86_di_dga_reinit_internal (ScreenPtr pScreen)

-{

-    ScrnInfoPtr		scrn = xf86Screens[pScreen->myNum];

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    

-    if (!DGAAvailable(pScreen->myNum))

-	return TRUE;

-

-    if (!xf86_dga_get_modes (pScreen))

-	return FALSE;

-    

-    return DGAReInitModes (pScreen, xf86_config->dga_modes, xf86_config->dga_nmode);

-}

-

-Bool

-xf86DiDGAInit (ScreenPtr pScreen, unsigned long dga_address)

-{

-    return TRUE;

-}

-

-Bool

-_xf86_di_dga_init_internal (ScreenPtr pScreen)

-{

-    ScrnInfoPtr		scrn = xf86Screens[pScreen->myNum];

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-

-    xf86_config->dga_flags = 0;

-    xf86_config->dga_address = 0;

-    xf86_config->dga_width = 0;

-    xf86_config->dga_height = 0;

-    xf86_config->dga_stride = 0;

-    

-    if (!xf86_dga_get_modes (pScreen))

-	return FALSE;

-    

-    return DGAInit(pScreen, &xf86_dga_funcs, xf86_config->dga_modes, xf86_config->dga_nmode);

-}

+/*
+ * Copyright © 2006 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#else
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#endif
+
+#include "xf86.h"
+#include "xf86DDC.h"
+#include "xf86_OSproc.h"
+#include "dgaproc.h"
+#include "xf86Crtc.h"
+#include "xf86Modes.h"
+#include "gcstruct.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+static Bool
+xf86_dga_get_modes(ScreenPtr pScreen)
+{
+    ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    DGAModePtr modes, mode;
+    DisplayModePtr display_mode;
+    int bpp = scrn->bitsPerPixel >> 3;
+    int num;
+
+    num = 0;
+    display_mode = scrn->modes;
+    while (display_mode) {
+        num++;
+        display_mode = display_mode->next;
+        if (display_mode == scrn->modes)
+            break;
+    }
+
+    if (!num)
+        return FALSE;
+
+    modes = malloc(num * sizeof(DGAModeRec));
+    if (!modes)
+        return FALSE;
+
+    num = 0;
+    display_mode = scrn->modes;
+    while (display_mode) {
+        mode = modes + num++;
+
+        mode->mode = display_mode;
+        mode->flags = DGA_CONCURRENT_ACCESS;
+        if (display_mode->Flags & V_DBLSCAN)
+            mode->flags |= DGA_DOUBLESCAN;
+        if (display_mode->Flags & V_INTERLACE)
+            mode->flags |= DGA_INTERLACED;
+        mode->byteOrder = scrn->imageByteOrder;
+        mode->depth = scrn->depth;
+        mode->bitsPerPixel = scrn->bitsPerPixel;
+        mode->red_mask = scrn->mask.red;
+        mode->green_mask = scrn->mask.green;
+        mode->blue_mask = scrn->mask.blue;
+        mode->visualClass = (bpp == 1) ? PseudoColor : TrueColor;
+        mode->viewportWidth = display_mode->HDisplay;
+        mode->viewportHeight = display_mode->VDisplay;
+        mode->xViewportStep = (bpp == 3) ? 2 : 1;
+        mode->yViewportStep = 1;
+        mode->viewportFlags = DGA_FLIP_RETRACE;
+        mode->offset = 0;
+        mode->address = 0;
+        mode->imageWidth = mode->viewportWidth;
+        mode->imageHeight = mode->viewportHeight;
+        mode->bytesPerScanline = (mode->imageWidth * scrn->bitsPerPixel) >> 3;
+        mode->pixmapWidth = mode->imageWidth;
+        mode->pixmapHeight = mode->imageHeight;
+        mode->maxViewportX = 0;
+        mode->maxViewportY = 0;
+
+        display_mode = display_mode->next;
+        if (display_mode == scrn->modes)
+            break;
+    }
+    free(xf86_config->dga_modes);
+    xf86_config->dga_nmode = num;
+    xf86_config->dga_modes = modes;
+    return TRUE;
+}
+
+static Bool
+xf86_dga_set_mode(ScrnInfoPtr scrn, DGAModePtr display_mode)
+{
+    ScreenPtr pScreen = scrn->pScreen;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    if (!display_mode) {
+        if (xf86_config->dga_save_mode) {
+            xf86SwitchMode(pScreen, xf86_config->dga_save_mode);
+            xf86_config->dga_save_mode = NULL;
+        }
+    }
+    else {
+        if (!xf86_config->dga_save_mode) {
+            xf86_config->dga_save_mode = scrn->currentMode;
+            xf86SwitchMode(pScreen, display_mode->mode);
+        }
+    }
+    return TRUE;
+}
+
+static int
+xf86_dga_get_viewport(ScrnInfoPtr scrn)
+{
+    return 0;
+}
+
+static void
+xf86_dga_set_viewport(ScrnInfoPtr scrn, int x, int y, int flags)
+{
+    scrn->AdjustFrame(scrn->pScreen->myNum, x, y, flags);
+}
+
+static Bool
+xf86_dga_open_framebuffer(ScrnInfoPtr scrn,
+                          char **name,
+                          unsigned char **mem, int *size, int *offset,
+                          int *flags)
+{
+    return FALSE;
+}
+
+static void
+xf86_dga_close_framebuffer(ScrnInfoPtr scrn)
+{
+}
+
+static DGAFunctionRec xf86_dga_funcs = {
+    xf86_dga_open_framebuffer,
+    xf86_dga_close_framebuffer,
+    xf86_dga_set_mode,
+    xf86_dga_set_viewport,
+    xf86_dga_get_viewport,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+Bool
+xf86DiDGAReInit(ScreenPtr pScreen)
+{
+    return TRUE;
+}
+
+Bool
+_xf86_di_dga_reinit_internal(ScreenPtr pScreen)
+{
+    ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    if (!DGAAvailable(pScreen->myNum))
+        return TRUE;
+
+    if (!xf86_dga_get_modes(pScreen))
+        return FALSE;
+
+    return DGAReInitModes(pScreen, xf86_config->dga_modes,
+                          xf86_config->dga_nmode);
+}
+
+Bool
+xf86DiDGAInit(ScreenPtr pScreen, unsigned long dga_address)
+{
+    return TRUE;
+}
+
+Bool
+_xf86_di_dga_init_internal(ScreenPtr pScreen)
+{
+    ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    xf86_config->dga_flags = 0;
+    xf86_config->dga_address = 0;
+    xf86_config->dga_width = 0;
+    xf86_config->dga_height = 0;
+    xf86_config->dga_stride = 0;
+
+    if (!xf86_dga_get_modes(pScreen))
+        return FALSE;
+
+    return DGAInit(pScreen, &xf86_dga_funcs, xf86_config->dga_modes,
+                   xf86_config->dga_nmode);
+}
diff --git a/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c b/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c
index d507e3b14..781c806bc 100644
--- a/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c
+++ b/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c
@@ -1,437 +1,452 @@
-/*

- * Copyright 2009 Red Hat, Inc.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software")

- * to deal in the software without restriction, including without limitation

- * on the rights to use, copy, modify, merge, publish, distribute, sub

- * license, and/or sell copies of the Software, and to permit persons to whom

- * them Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTIBILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER

- * IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF OR IN

- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- *

- * Authors:

- *	Adam Jackson <ajax@redhat.com>

- */

-

-#include "xorg-config.h"

-#include "xf86.h"

-#include "xf86str.h"

-#include "edid.h"

-#include "xf86DDC.h"

-

-typedef void (*did_proc)(int scrnIndex, unsigned char *data, void *closure);

-

-#define DID_PRODUCT_ID		    0x00

-#define DID_DISPLAY_PARAMETERS	    0x01

-#define DID_COLOR_INFO		    0x02

-#define DID_TIMING_1_DETAILED	    0x03

-#define DID_TIMING_2_DETAILED	    0x04

-#define DID_TIMING_3_SHORT	    0x05

-#define DID_TIMING_4_DMT	    0x06

-#define DID_TIMING_VESA		    0x07

-#define DID_TIMING_CEA		    0x08

-#define DID_TIMING_RANGE_LIMITS	    0x09

-#define DID_PRODUCT_SERIAL	    0x0A

-#define DID_ASCII_STRING	    0x0B

-#define DID_DISPLAY_DEVICE	    0x0C

-#define DID_POWER_SEQUENCING	    0x0D

-#define DID_TRANSFER_INFO	    0x0E

-#define DID_DISPLAY_INTERFACE	    0x0F

-#define DID_STEREO		    0x10

-#define DID_VENDOR		    0x7F

-

-#define extract_le16(x, i) ((x[i+1] << 8) + (x[i]))

-#define extract_le24(x, i) ((x[i+2] << 16) + (x[i+1] << 8) + (x[i]))

-

-static DisplayModePtr

-modeCalloc(void)

-{

-    return calloc(1, sizeof(DisplayModeRec));

-}

-

-/*

- * How awesome is it to have two detailed timing formats, neither of which

- * are compatible with the format in EDID?  So awesome.

- */

-

-static void

-didDetailedTiming1(int i, unsigned char *x, MonPtr mon)

-{

-    DisplayModePtr m = modeCalloc();

-

-    if (!m)

-	return;

-

-    m->Clock = extract_le24(x, 0);

-

-    m->HDisplay = extract_le16(x, 4);

-    m->HSyncStart = m->HDisplay + (extract_le16(x, 8) & 0x7f);

-    m->HSyncEnd = m->HSyncStart + extract_le16(x, 10);

-    m->HTotal = m->HDisplay + extract_le16(x, 6);

-    m->Flags |= (x[9] & 0x80) ? V_PHSYNC : V_NHSYNC;

-

-    m->VDisplay = extract_le16(x, 12);

-    m->VSyncStart = m->VDisplay + (extract_le16(x, 16) & 0x7f);

-    m->VSyncEnd = m->VSyncStart + extract_le16(x, 18);

-    m->VTotal = m->VDisplay + extract_le16(x, 14);

-    m->Flags |= (x[17] & 0x80) ? V_PVSYNC : V_NVSYNC;

-

-    m->type = M_T_DRIVER;

-    if (x[3] & 0x80)

-	m->type |= M_T_PREFERRED;

-

-    /* XXX double check handling of this */

-    if (x[3] & 0x10)

-	m->Flags |= V_INTERLACE;

-

-    mon->Modes = xf86ModesAdd(mon->Modes, m);

-}

-

-/* XXX no sync bits.  what to do? */

-static void

-didDetailedTiming2(int i, unsigned char *x, MonPtr mon)

-{

-    DisplayModePtr mode = modeCalloc();

-

-    if (!mode)

-	return;

-

-    mode->Clock = extract_le24(x, 0);

-

-    /* horiz sizes are in character cells, not pixels, hence * 8 */

-    mode->HDisplay = ((extract_le16(x, 4) & 0x01ff) + 1) * 8;

-    mode->HSyncStart = mode->HDisplay + (((x[6] & 0xf0) >> 4) + 1) * 8;

-    mode->HSyncEnd = mode->HSyncStart + ((x[6] & 0x0f) + 1) * 8;

-    mode->HTotal = mode->HDisplay + ((x[5] >> 1) + 1) * 8;

-

-    mode->VDisplay = extract_le16(x, 7) & 0x07ff;

-    mode->VSyncStart = mode->VDisplay + (x[10] >> 4) + 1;

-    mode->VSyncEnd = mode->VSyncStart + (x[10] & 0x0f) + 1;

-    mode->VTotal = mode->VDisplay + x[9];

-

-    mode->status = M_T_DRIVER;

-    if (x[3] & 0x80)

-	mode->status |= M_T_PREFERRED;

-

-    /* XXX double check handling of this */

-    if (x[3] & 0x10)

-	mode->Flags |= V_INTERLACE;

-

-    mon->Modes = xf86ModesAdd(mon->Modes, mode);

-}

-

-static void

-didShortTiming(int i, unsigned char *x, MonPtr mon)

-{

-    DisplayModePtr m;

-    int w, h, r;

-

-    w = (x[1] + 1) * 8;

-    switch (x[0] & 0x0f) {

-	case 0:

-	    h = w;

-	    break;

-	case 1:

-	    h = (w * 4) / 5;

-	    break;

-	case 2:

-	    h = (w * 3) / 4;

-	    break;

-	case 3:

-	    h = (w * 9) / 15;

-	    break;

-	case 4:

-	    h = (w * 9) / 16;

-	    break;

-	case 5:

-	    h = (w * 10) / 16;

-	    break;

-	default:

-	    return;

-    }

-    r = (x[2] & 0x7f) + 1;

- 

-    m = xf86CVTMode(w, h, r, !!(x[0] & 0x10), !!(x[2] & 0x80));

-

-    m->type = M_T_DRIVER;

-    if (x[0] & 0x80)

-	m->type |= M_T_PREFERRED;

-

-    mon->Modes = xf86ModesAdd(mon->Modes, m);

-}

-

-static void

-didDMTTiming(int i, unsigned char *x, void *closure)

-{

-    MonPtr mon = closure;

-

-    mon->Modes = xf86ModesAdd(mon->Modes,

-			      xf86DuplicateMode(DMTModes + *x));

-}

-

-#define RB 1

-#define INT 2

-static const struct did_dmt {

-    short w, h, r, f;

-} did_dmt[] = {

-    /* byte 3 */

-    { 640, 350, 85, 0 },

-    { 640, 400, 85, 0 },

-    { 720, 400, 85, 0 },

-    { 640, 480, 60, 0 },

-    { 640, 480, 72, 0 },

-    { 640, 480, 75, 0 },

-    { 640, 480, 85, 0 },

-    { 800, 600, 56, 0 },

-    /* byte 4 */

-    { 800, 600, 60, 0 },

-    { 800, 600, 72, 0 },

-    { 800, 600, 75, 0 },

-    { 800, 600, 85, 0 },

-    { 800, 600, 120, RB },

-    { 848, 480, 60, 0 },

-    { 1024, 768, 43, INT },

-    { 1024, 768, 60, 0 },

-    /* byte 5 */

-    { 1024, 768, 70, 0 },

-    { 1024, 768, 75, 0 },

-    { 1024, 768, 85, 0 },

-    { 1024, 768, 120, RB },

-    { 1152, 864, 75, 0 },

-    { 1280, 768, 60, RB },

-    { 1280, 768, 60, 0 },

-    { 1280, 768, 75, 0 },

-    /* byte 6 */

-    { 1280, 768, 85, 0 },

-    { 1280, 768, 120, RB },

-    { 1280, 800, 60, RB },

-    { 1280, 800, 60, 0 },

-    { 1280, 800, 75, 0 },

-    { 1280, 800, 85, 0 },

-    { 1280, 800, 120, RB },

-    { 1280, 960, 60, 0 },

-    /* byte 7 */

-    { 1280, 960, 85, 0 },

-    { 1280, 960, 120, RB },

-    { 1280, 1024, 60, 0 },

-    { 1280, 1024, 75, 0 },

-    { 1280, 1024, 85, 0 },

-    { 1280, 1024, 120, RB },

-    { 1360, 768, 60, 0 },

-    { 1360, 768, 120, RB },

-    /* byte 8 */

-    { 1400, 1050, 60, RB },

-    { 1400, 1050, 60, 0 },

-    { 1400, 1050, 75, 0 },

-    { 1400, 1050, 85, 0 },

-    { 1400, 1050, 120, RB },

-    { 1440, 900, 60, RB },

-    { 1440, 900, 60, 0 },

-    { 1440, 900, 75, 0 },

-    /* byte 9 */

-    { 1440, 900, 85, 0 },

-    { 1440, 900, 120, RB },

-    { 1600, 1200, 60, 0 },

-    { 1600, 1200, 65, 0 },

-    { 1600, 1200, 70, 0 },

-    { 1600, 1200, 75, 0 },

-    { 1600, 1200, 85, 0 },

-    { 1600, 1200, 120, RB },

-    /* byte a */

-    { 1680, 1050, 60, RB },

-    { 1680, 1050, 60, 0 },

-    { 1680, 1050, 75, 0 },

-    { 1680, 1050, 85, 0 },

-    { 1680, 1050, 120, RB },

-    { 1792, 1344, 60, 0 },

-    { 1792, 1344, 75, 0 },

-    { 1792, 1344, 120, RB },

-    /* byte b */

-    { 1856, 1392, 60, 0 },

-    { 1856, 1392, 75, 0 },

-    { 1856, 1392, 120, RB },

-    { 1920, 1200, 60, RB },

-    { 1920, 1200, 60, 0 },

-    { 1920, 1200, 75, 0 },

-    { 1920, 1200, 85, 0 },

-    { 1920, 1200, 120, RB },

-    /* byte c */

-    { 1920, 1440, 60, 0 },

-    { 1920, 1440, 75, 0 },

-    { 1920, 1440, 120, RB },

-    { 2560, 1600, 60, RB },

-    { 2560, 1600, 60, 0 },

-    { 2560, 1600, 75, 0 },

-    { 2560, 1600, 85, 0 },

-    { 2560, 1600, 120, RB },

-};

-

-static void

-didVesaTiming(int scrn, unsigned char *x, MonPtr mon)

-{

-    int i, j;

-

-    x += 3;

-    

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

-	for (j = 0; j < 8; j++)

-	    if (x[i] & (1 << j)) {

-		const struct did_dmt *d = &(did_dmt[i * 8 + j]);

-		if (d->f == INT)

-		    continue;

-		mon->Modes = xf86ModesAdd(mon->Modes,

-					  FindDMTMode(d->w, d->h, d->r,

-						      d->f == RB));

-	    }

-

-}

-

-static void

-handleDisplayIDBlock(int scrnIndex, unsigned char *x, void *closure)

-{

-    MonPtr mon = closure;

-

-    switch (x[0]) {

-	case DID_DISPLAY_PARAMETERS:

-	    /* w/h are in decimillimeters */

-	    mon->widthmm = (extract_le16(x, 3) + 5) / 10;

-	    mon->heightmm = (extract_le16(x, 5) + 5) / 10;

-	    /* XXX pixel count, feature flags, gamma, aspect, color depth */

-	    break;

-

-	case DID_TIMING_RANGE_LIMITS:

-	{

-	    int n;

-

-	    mon->maxPixClock = max(mon->maxPixClock, extract_le24(x, 6) * 10);

-

-	    n = mon->nHsync++;

-	    if (n < MAX_HSYNC) {

-		mon->hsync[n].lo = x[9];

-		mon->hsync[n].hi = x[10];

-	    } else {

-		n = MAX_HSYNC;

-	    }

-	    n = mon->nVrefresh++;

-	    if (n < MAX_VREFRESH) {

-		mon->vrefresh[n].lo = x[13];

-		mon->vrefresh[n].hi = x[14];

-	    } else {

-		n = MAX_VREFRESH;

-	    }

-	    break;

-	}

-

-	case DID_TIMING_1_DETAILED:

-	{

-	    int i;

-	    for (i = 0; i < x[2]; i += 20)

-		didDetailedTiming1(scrnIndex, x + i + 3, mon);

-	    break;

-	}

-

-	case DID_TIMING_2_DETAILED:

-	{

-	    int i;

-	    for (i = 0; i < x[2]; i += 11)

-		didDetailedTiming2(scrnIndex, x + i + 3, mon);

-	    break;

-	}

-

-	case DID_TIMING_3_SHORT:

-	{

-	    int i;

-	    for (i = 0; i < x[2]; i += 3)

-		didShortTiming(scrnIndex, x + i + 3, mon);

-	    break;

-	}

-

-	case DID_TIMING_4_DMT:

-	{

-	    int i;

-	    for (i = 0; i < x[2]; i++)

-		didDMTTiming(scrnIndex, x + i + 3, mon);

-	    break;

-	}

-

-	case DID_TIMING_VESA:

-	    didVesaTiming(scrnIndex, x, mon);

-	    break;

-

-	/* XXX pixel format, ar, orientation, subpixel, dot pitch, bit depth */

-	case DID_DISPLAY_DEVICE:

-

-	/* XXX interface, links, color encoding, ss, drm */

-	case DID_DISPLAY_INTERFACE:

-

-	/* XXX stereo */

-	case DID_STEREO:

-

-	/* nothing interesting in these */

-	case DID_COLOR_INFO:

-	case DID_PRODUCT_SERIAL:

-	case DID_ASCII_STRING:

-	case DID_POWER_SEQUENCING:

-	case DID_TRANSFER_INFO:

-	case DID_VENDOR:

-	    break;

-

-	/* warn about anything else */

-	default:

-	    xf86DrvMsg(scrnIndex, X_WARNING,

-		       "Unknown DisplayID block type %hx\n", x[0]);

-	    break;

-    }

-}

-

-static void

-forEachDisplayIDBlock(int scrnIndex, unsigned char *did, did_proc proc,

-		      void *closure)

-{

-    int num_extensions = did[3];

-    int section_size = did[1];

-    unsigned char *block;

-

-    do {

-	if ((did[0] & 0xf0) != 0x10) /* not 1.x, abort */

-	    return;

-	/* XXX also, checksum */

-

-	block = did + 4;

-

-	while (section_size > 0) {

-	    int block_size = (block[2] + 2);

-

-	    proc(scrnIndex, block, closure);

-

-	    section_size -= block_size;

-	    block += block_size;

-	}

-

-	did += (did[1] + 5);

-    } while (num_extensions--);

-}

-

-/*

- * Fill out MonPtr with xf86MonPtr information.

- */

-void

-xf86DisplayIDMonitorSet(int scrnIndex, MonPtr mon, xf86MonPtr DDC)

-{

-    if (!mon || !DDC)

-        return;

-

-    mon->DDC = DDC;

-

-    forEachDisplayIDBlock(scrnIndex, DDC->rawData, handleDisplayIDBlock, mon);

-}

+/*
+ * Copyright 2009 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software")
+ * to deal in the software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * them Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTIBILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *	Adam Jackson <ajax@redhat.com>
+ */
+
+#include "xorg-config.h"
+#include "xf86.h"
+#include "xf86str.h"
+#include "edid.h"
+#include "xf86DDC.h"
+
+typedef void (*did_proc) (int scrnIndex, unsigned char *data, void *closure);
+
+#define DID_PRODUCT_ID		    0x00
+#define DID_DISPLAY_PARAMETERS	    0x01
+#define DID_COLOR_INFO		    0x02
+#define DID_TIMING_1_DETAILED	    0x03
+#define DID_TIMING_2_DETAILED	    0x04
+#define DID_TIMING_3_SHORT	    0x05
+#define DID_TIMING_4_DMT	    0x06
+#define DID_TIMING_VESA		    0x07
+#define DID_TIMING_CEA		    0x08
+#define DID_TIMING_RANGE_LIMITS	    0x09
+#define DID_PRODUCT_SERIAL	    0x0A
+#define DID_ASCII_STRING	    0x0B
+#define DID_DISPLAY_DEVICE	    0x0C
+#define DID_POWER_SEQUENCING	    0x0D
+#define DID_TRANSFER_INFO	    0x0E
+#define DID_DISPLAY_INTERFACE	    0x0F
+#define DID_STEREO		    0x10
+#define DID_VENDOR		    0x7F
+
+#define extract_le16(x, i) ((x[i+1] << 8) + (x[i]))
+#define extract_le24(x, i) ((x[i+2] << 16) + (x[i+1] << 8) + (x[i]))
+
+static DisplayModePtr
+modeCalloc(void)
+{
+    return calloc(1, sizeof(DisplayModeRec));
+}
+
+/*
+ * How awesome is it to have two detailed timing formats, neither of which
+ * are compatible with the format in EDID?  So awesome.
+ */
+
+static void
+didDetailedTiming1(int i, unsigned char *x, MonPtr mon)
+{
+    DisplayModePtr m = modeCalloc();
+
+    if (!m)
+        return;
+
+    m->Clock = extract_le24(x, 0);
+
+    m->HDisplay = extract_le16(x, 4);
+    m->HSyncStart = m->HDisplay + (extract_le16(x, 8) & 0x7f);
+    m->HSyncEnd = m->HSyncStart + extract_le16(x, 10);
+    m->HTotal = m->HDisplay + extract_le16(x, 6);
+    m->Flags |= (x[9] & 0x80) ? V_PHSYNC : V_NHSYNC;
+
+    m->VDisplay = extract_le16(x, 12);
+    m->VSyncStart = m->VDisplay + (extract_le16(x, 16) & 0x7f);
+    m->VSyncEnd = m->VSyncStart + extract_le16(x, 18);
+    m->VTotal = m->VDisplay + extract_le16(x, 14);
+    m->Flags |= (x[17] & 0x80) ? V_PVSYNC : V_NVSYNC;
+
+    m->type = M_T_DRIVER;
+    if (x[3] & 0x80)
+        m->type |= M_T_PREFERRED;
+
+    /* XXX double check handling of this */
+    if (x[3] & 0x10)
+        m->Flags |= V_INTERLACE;
+
+    mon->Modes = xf86ModesAdd(mon->Modes, m);
+}
+
+/* XXX no sync bits.  what to do? */
+static void
+didDetailedTiming2(int i, unsigned char *x, MonPtr mon)
+{
+    DisplayModePtr mode = modeCalloc();
+
+    if (!mode)
+        return;
+
+    mode->Clock = extract_le24(x, 0);
+
+    /* horiz sizes are in character cells, not pixels, hence * 8 */
+    mode->HDisplay = ((extract_le16(x, 4) & 0x01ff) + 1) * 8;
+    mode->HSyncStart = mode->HDisplay + (((x[6] & 0xf0) >> 4) + 1) * 8;
+    mode->HSyncEnd = mode->HSyncStart + ((x[6] & 0x0f) + 1) * 8;
+    mode->HTotal = mode->HDisplay + ((x[5] >> 1) + 1) * 8;
+
+    mode->VDisplay = extract_le16(x, 7) & 0x07ff;
+    mode->VSyncStart = mode->VDisplay + (x[10] >> 4) + 1;
+    mode->VSyncEnd = mode->VSyncStart + (x[10] & 0x0f) + 1;
+    mode->VTotal = mode->VDisplay + x[9];
+
+    mode->status = M_T_DRIVER;
+    if (x[3] & 0x80)
+        mode->status |= M_T_PREFERRED;
+
+    /* XXX double check handling of this */
+    if (x[3] & 0x10)
+        mode->Flags |= V_INTERLACE;
+
+    mon->Modes = xf86ModesAdd(mon->Modes, mode);
+}
+
+static void
+didShortTiming(int i, unsigned char *x, MonPtr mon)
+{
+    DisplayModePtr m;
+    int w, h, r;
+
+    w = (x[1] + 1) * 8;
+    switch (x[0] & 0x0f) {
+    case 0:
+        h = w;
+        break;
+    case 1:
+        h = (w * 4) / 5;
+        break;
+    case 2:
+        h = (w * 3) / 4;
+        break;
+    case 3:
+        h = (w * 9) / 15;
+        break;
+    case 4:
+        h = (w * 9) / 16;
+        break;
+    case 5:
+        h = (w * 10) / 16;
+        break;
+    default:
+        return;
+    }
+    r = (x[2] & 0x7f) + 1;
+
+    m = xf86CVTMode(w, h, r, ! !(x[0] & 0x10), ! !(x[2] & 0x80));
+
+    m->type = M_T_DRIVER;
+    if (x[0] & 0x80)
+        m->type |= M_T_PREFERRED;
+
+    mon->Modes = xf86ModesAdd(mon->Modes, m);
+}
+
+static void
+didDMTTiming(int i, unsigned char *x, void *closure)
+{
+    MonPtr mon = closure;
+
+    mon->Modes = xf86ModesAdd(mon->Modes, xf86DuplicateMode(DMTModes + *x));
+}
+
+#define RB 1
+#define INT 2
+static const struct did_dmt {
+    short w, h, r, f;
+} did_dmt[] = {
+    /* byte 3 */
+    {
+    640, 350, 85, 0}, {
+    640, 400, 85, 0}, {
+    720, 400, 85, 0}, {
+    640, 480, 60, 0}, {
+    640, 480, 72, 0}, {
+    640, 480, 75, 0}, {
+    640, 480, 85, 0}, {
+    800, 600, 56, 0},
+        /* byte 4 */
+    {
+    800, 600, 60, 0}, {
+    800, 600, 72, 0}, {
+    800, 600, 75, 0}, {
+    800, 600, 85, 0}, {
+    800, 600, 120, RB}, {
+    848, 480, 60, 0}, {
+    1024, 768, 43, INT}, {
+    1024, 768, 60, 0},
+        /* byte 5 */
+    {
+    1024, 768, 70, 0}, {
+    1024, 768, 75, 0}, {
+    1024, 768, 85, 0}, {
+    1024, 768, 120, RB}, {
+    1152, 864, 75, 0}, {
+    1280, 768, 60, RB}, {
+    1280, 768, 60, 0}, {
+    1280, 768, 75, 0},
+        /* byte 6 */
+    {
+    1280, 768, 85, 0}, {
+    1280, 768, 120, RB}, {
+    1280, 800, 60, RB}, {
+    1280, 800, 60, 0}, {
+    1280, 800, 75, 0}, {
+    1280, 800, 85, 0}, {
+    1280, 800, 120, RB}, {
+    1280, 960, 60, 0},
+        /* byte 7 */
+    {
+    1280, 960, 85, 0}, {
+    1280, 960, 120, RB}, {
+    1280, 1024, 60, 0}, {
+    1280, 1024, 75, 0}, {
+    1280, 1024, 85, 0}, {
+    1280, 1024, 120, RB}, {
+    1360, 768, 60, 0}, {
+    1360, 768, 120, RB},
+        /* byte 8 */
+    {
+    1400, 1050, 60, RB}, {
+    1400, 1050, 60, 0}, {
+    1400, 1050, 75, 0}, {
+    1400, 1050, 85, 0}, {
+    1400, 1050, 120, RB}, {
+    1440, 900, 60, RB}, {
+    1440, 900, 60, 0}, {
+    1440, 900, 75, 0},
+        /* byte 9 */
+    {
+    1440, 900, 85, 0}, {
+    1440, 900, 120, RB}, {
+    1600, 1200, 60, 0}, {
+    1600, 1200, 65, 0}, {
+    1600, 1200, 70, 0}, {
+    1600, 1200, 75, 0}, {
+    1600, 1200, 85, 0}, {
+    1600, 1200, 120, RB},
+        /* byte a */
+    {
+    1680, 1050, 60, RB}, {
+    1680, 1050, 60, 0}, {
+    1680, 1050, 75, 0}, {
+    1680, 1050, 85, 0}, {
+    1680, 1050, 120, RB}, {
+    1792, 1344, 60, 0}, {
+    1792, 1344, 75, 0}, {
+    1792, 1344, 120, RB},
+        /* byte b */
+    {
+    1856, 1392, 60, 0}, {
+    1856, 1392, 75, 0}, {
+    1856, 1392, 120, RB}, {
+    1920, 1200, 60, RB}, {
+    1920, 1200, 60, 0}, {
+    1920, 1200, 75, 0}, {
+    1920, 1200, 85, 0}, {
+    1920, 1200, 120, RB},
+        /* byte c */
+    {
+    1920, 1440, 60, 0}, {
+    1920, 1440, 75, 0}, {
+    1920, 1440, 120, RB}, {
+    2560, 1600, 60, RB}, {
+    2560, 1600, 60, 0}, {
+    2560, 1600, 75, 0}, {
+    2560, 1600, 85, 0}, {
+2560, 1600, 120, RB},};
+
+static void
+didVesaTiming(int scrn, unsigned char *x, MonPtr mon)
+{
+    int i, j;
+
+    x += 3;
+
+    for (i = 0; i < 10; i++)
+        for (j = 0; j < 8; j++)
+            if (x[i] & (1 << j)) {
+                const struct did_dmt *d = &(did_dmt[i * 8 + j]);
+
+                if (d->f == INT)
+                    continue;
+                mon->Modes = xf86ModesAdd(mon->Modes,
+                                          FindDMTMode(d->w, d->h, d->r,
+                                                      d->f == RB));
+            }
+
+}
+
+static void
+handleDisplayIDBlock(int scrnIndex, unsigned char *x, void *closure)
+{
+    MonPtr mon = closure;
+
+    switch (x[0]) {
+    case DID_DISPLAY_PARAMETERS:
+        /* w/h are in decimillimeters */
+        mon->widthmm = (extract_le16(x, 3) + 5) / 10;
+        mon->heightmm = (extract_le16(x, 5) + 5) / 10;
+        /* XXX pixel count, feature flags, gamma, aspect, color depth */
+        break;
+
+    case DID_TIMING_RANGE_LIMITS:
+    {
+        int n;
+
+        mon->maxPixClock = max(mon->maxPixClock, extract_le24(x, 6) * 10);
+
+        n = mon->nHsync++;
+        if (n < MAX_HSYNC) {
+            mon->hsync[n].lo = x[9];
+            mon->hsync[n].hi = x[10];
+        }
+        else {
+            n = MAX_HSYNC;
+        }
+        n = mon->nVrefresh++;
+        if (n < MAX_VREFRESH) {
+            mon->vrefresh[n].lo = x[13];
+            mon->vrefresh[n].hi = x[14];
+        }
+        else {
+            n = MAX_VREFRESH;
+        }
+        break;
+    }
+
+    case DID_TIMING_1_DETAILED:
+    {
+        int i;
+
+        for (i = 0; i < x[2]; i += 20)
+            didDetailedTiming1(scrnIndex, x + i + 3, mon);
+        break;
+    }
+
+    case DID_TIMING_2_DETAILED:
+    {
+        int i;
+
+        for (i = 0; i < x[2]; i += 11)
+            didDetailedTiming2(scrnIndex, x + i + 3, mon);
+        break;
+    }
+
+    case DID_TIMING_3_SHORT:
+    {
+        int i;
+
+        for (i = 0; i < x[2]; i += 3)
+            didShortTiming(scrnIndex, x + i + 3, mon);
+        break;
+    }
+
+    case DID_TIMING_4_DMT:
+    {
+        int i;
+
+        for (i = 0; i < x[2]; i++)
+            didDMTTiming(scrnIndex, x + i + 3, mon);
+        break;
+    }
+
+    case DID_TIMING_VESA:
+        didVesaTiming(scrnIndex, x, mon);
+        break;
+
+        /* XXX pixel format, ar, orientation, subpixel, dot pitch, bit depth */
+    case DID_DISPLAY_DEVICE:
+
+        /* XXX interface, links, color encoding, ss, drm */
+    case DID_DISPLAY_INTERFACE:
+
+        /* XXX stereo */
+    case DID_STEREO:
+
+        /* nothing interesting in these */
+    case DID_COLOR_INFO:
+    case DID_PRODUCT_SERIAL:
+    case DID_ASCII_STRING:
+    case DID_POWER_SEQUENCING:
+    case DID_TRANSFER_INFO:
+    case DID_VENDOR:
+        break;
+
+        /* warn about anything else */
+    default:
+        xf86DrvMsg(scrnIndex, X_WARNING,
+                   "Unknown DisplayID block type %hx\n", x[0]);
+        break;
+    }
+}
+
+static void
+forEachDisplayIDBlock(int scrnIndex, unsigned char *did, did_proc proc,
+                      void *closure)
+{
+    int num_extensions = did[3];
+    int section_size = did[1];
+    unsigned char *block;
+
+    do {
+        if ((did[0] & 0xf0) != 0x10)    /* not 1.x, abort */
+            return;
+        /* XXX also, checksum */
+
+        block = did + 4;
+
+        while (section_size > 0) {
+            int block_size = (block[2] + 2);
+
+            proc(scrnIndex, block, closure);
+
+            section_size -= block_size;
+            block += block_size;
+        }
+
+        did += (did[1] + 5);
+    } while (num_extensions--);
+}
+
+/*
+ * Fill out MonPtr with xf86MonPtr information.
+ */
+void
+xf86DisplayIDMonitorSet(int scrnIndex, MonPtr mon, xf86MonPtr DDC)
+{
+    if (!mon || !DDC)
+        return;
+
+    mon->DDC = DDC;
+
+    forEachDisplayIDBlock(scrnIndex, DDC->rawData, handleDisplayIDBlock, mon);
+}
diff --git a/xorg-server/hw/xfree86/modes/xf86EdidModes.c b/xorg-server/hw/xfree86/modes/xf86EdidModes.c
index 0100d2a59..8aa82d114 100644
--- a/xorg-server/hw/xfree86/modes/xf86EdidModes.c
+++ b/xorg-server/hw/xfree86/modes/xf86EdidModes.c
@@ -45,12 +45,12 @@
 #include <string.h>
 #include <math.h>
 
-static void handle_detailed_rblank(struct detailed_monitor_section *det_mon,
-                                   void *data)
+static void
+handle_detailed_rblank(struct detailed_monitor_section *det_mon, void *data)
 {
     if (det_mon->type == DS_RANGES)
         if (det_mon->section.ranges.supported_blanking & CVT_REDUCED)
-            *(Bool*)data = TRUE;
+            *(Bool *) data = TRUE;
 }
 
 static Bool
@@ -71,209 +71,189 @@ xf86MonitorSupportsReducedBlanking(xf86MonPtr DDC)
     return FALSE;
 }
 
-static Bool quirk_prefer_large_60 (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_prefer_large_60(int scrnIndex, xf86MonPtr DDC)
 {
     /* Belinea 10 15 55 */
-    if (memcmp (DDC->vendor.name, "MAX", 4) == 0 &&
-	((DDC->vendor.prod_id == 1516) ||
-	(DDC->vendor.prod_id == 0x77e)))
-	return TRUE;
-    
+    if (memcmp(DDC->vendor.name, "MAX", 4) == 0 &&
+        ((DDC->vendor.prod_id == 1516) || (DDC->vendor.prod_id == 0x77e)))
+        return TRUE;
+
     /* Acer AL1706 */
-    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&
-	DDC->vendor.prod_id == 44358)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "ACR", 4) == 0 && DDC->vendor.prod_id == 44358)
+        return TRUE;
 
     /* Bug #10814: Samsung SyncMaster 225BW */
-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
-	DDC->vendor.prod_id == 596)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "SAM", 4) == 0 && DDC->vendor.prod_id == 596)
+        return TRUE;
 
     /* Bug #10545: Samsung SyncMaster 226BW */
-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
-	DDC->vendor.prod_id == 638)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "SAM", 4) == 0 && DDC->vendor.prod_id == 638)
+        return TRUE;
 
     /* Acer F51 */
-    if (memcmp (DDC->vendor.name, "API", 4) == 0 &&
-	DDC->vendor.prod_id == 0x7602)
-	return TRUE;
-
+    if (memcmp(DDC->vendor.name, "API", 4) == 0 &&
+        DDC->vendor.prod_id == 0x7602)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_prefer_large_75 (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_prefer_large_75(int scrnIndex, xf86MonPtr DDC)
 {
     /* Bug #11603: Funai Electronics PM36B */
-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
-	DDC->vendor.prod_id == 13600)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "FCM", 4) == 0 && DDC->vendor.prod_id == 13600)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_detailed_h_in_cm (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_detailed_h_in_cm(int scrnIndex, xf86MonPtr DDC)
 {
     /* Bug #11603: Funai Electronics PM36B */
-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
-	DDC->vendor.prod_id == 13600)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "FCM", 4) == 0 && DDC->vendor.prod_id == 13600)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_detailed_v_in_cm (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_detailed_v_in_cm(int scrnIndex, xf86MonPtr DDC)
 {
     /* Bug #11603: Funai Electronics PM36B */
-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
-	DDC->vendor.prod_id == 13600)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "FCM", 4) == 0 && DDC->vendor.prod_id == 13600)
+        return TRUE;
 
     /* Bug #21000: LGPhilipsLCD LP154W01-TLAJ */
-    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
-	DDC->vendor.prod_id == 47360)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 && DDC->vendor.prod_id == 47360)
+        return TRUE;
 
     /* Bug #10304: LGPhilipsLCD LP154W01-A5 */
-    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&
-	DDC->vendor.prod_id == 0)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 && DDC->vendor.prod_id == 0)
+        return TRUE;
 
     /* Bug #24482: LGPhilipsLCD LP154W01-TLA1 */
     if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&
-	DDC->vendor.prod_id == 0x2a00)
-	return TRUE;
+        DDC->vendor.prod_id == 0x2a00)
+        return TRUE;
 
     /* Bug #28414: HP Compaq NC8430 LP154W01-TLA8 */
-    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
-	DDC->vendor.prod_id == 5750)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 && DDC->vendor.prod_id == 5750)
+        return TRUE;
 
     /* Bug #21750: Samsung Syncmaster 2333HD */
-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
-	DDC->vendor.prod_id == 1157)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "SAM", 4) == 0 && DDC->vendor.prod_id == 1157)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_detailed_use_maximum_size (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_detailed_use_maximum_size(int scrnIndex, xf86MonPtr DDC)
 {
     /* Bug #21324: Iiyama Vision Master 450 */
-    if (memcmp (DDC->vendor.name, "IVM", 4) == 0 &&
-	DDC->vendor.prod_id == 6400)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "IVM", 4) == 0 && DDC->vendor.prod_id == 6400)
+        return TRUE;
 
     /* Bug #41141: Acer Aspire One */
-    if (memcmp (DDC->vendor.name, "LGD", 4) == 0 &&
-	DDC->vendor.prod_id == 0x7f01)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "LGD", 4) == 0 &&
+        DDC->vendor.prod_id == 0x7f01)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_135_clock_too_high (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_135_clock_too_high(int scrnIndex, xf86MonPtr DDC)
 {
     /* Envision Peripherals, Inc. EN-7100e.  See bug #9550. */
-    if (memcmp (DDC->vendor.name, "EPI", 4) == 0 &&
-	DDC->vendor.prod_id == 59264)
-	return TRUE;
-    
+    if (memcmp(DDC->vendor.name, "EPI", 4) == 0 && DDC->vendor.prod_id == 59264)
+        return TRUE;
+
     return FALSE;
 }
 
-static Bool quirk_first_detailed_preferred (int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_first_detailed_preferred(int scrnIndex, xf86MonPtr DDC)
 {
     /* Philips 107p5 CRT. Reported on xorg@ with pastebin. */
-    if (memcmp (DDC->vendor.name, "PHL", 4) == 0 &&
-	DDC->vendor.prod_id == 57364)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "PHL", 4) == 0 && DDC->vendor.prod_id == 57364)
+        return TRUE;
 
-    /* Proview AY765C 17" LCD. See bug #15160*/
-    if (memcmp (DDC->vendor.name, "PTS", 4) == 0 &&
-	DDC->vendor.prod_id == 765)
-	return TRUE;
+    /* Proview AY765C 17" LCD. See bug #15160 */
+    if (memcmp(DDC->vendor.name, "PTS", 4) == 0 && DDC->vendor.prod_id == 765)
+        return TRUE;
 
     /* ACR of some sort RH #284231 */
-    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&
-	DDC->vendor.prod_id == 2423)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "ACR", 4) == 0 && DDC->vendor.prod_id == 2423)
+        return TRUE;
 
     /* Peacock Ergovision 19.  See rh#492359 */
-    if (memcmp (DDC->vendor.name, "PEA", 4) == 0 &&
-	DDC->vendor.prod_id == 9003)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "PEA", 4) == 0 && DDC->vendor.prod_id == 9003)
+        return TRUE;
 
     return FALSE;
 }
 
-static Bool quirk_detailed_sync_pp(int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_detailed_sync_pp(int scrnIndex, xf86MonPtr DDC)
 {
     /* Bug #12439: Samsung SyncMaster 205BW */
-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
-	DDC->vendor.prod_id == 541)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "SAM", 4) == 0 && DDC->vendor.prod_id == 541)
+        return TRUE;
     return FALSE;
 }
 
 /* This should probably be made more generic */
-static Bool quirk_dvi_single_link(int scrnIndex, xf86MonPtr DDC)
+static Bool
+quirk_dvi_single_link(int scrnIndex, xf86MonPtr DDC)
 {
     /* Red Hat bug #453106: Apple 23" Cinema Display */
-    if (memcmp (DDC->vendor.name, "APL", 4) == 0 &&
-	DDC->vendor.prod_id == 0x921c)
-	return TRUE;
+    if (memcmp(DDC->vendor.name, "APL", 4) == 0 &&
+        DDC->vendor.prod_id == 0x921c)
+        return TRUE;
     return FALSE;
 }
 
 typedef struct {
-    Bool	(*detect) (int scrnIndex, xf86MonPtr DDC);
-    ddc_quirk_t	quirk;
-    const char	*description;
+    Bool (*detect) (int scrnIndex, xf86MonPtr DDC);
+    ddc_quirk_t quirk;
+    const char *description;
 } ddc_quirk_map_t;
 
 static const ddc_quirk_map_t ddc_quirks[] = {
     {
-	quirk_prefer_large_60,   DDC_QUIRK_PREFER_LARGE_60,
-	"Detailed timing is not preferred, use largest mode at 60Hz"
-    },
+     quirk_prefer_large_60, DDC_QUIRK_PREFER_LARGE_60,
+     "Detailed timing is not preferred, use largest mode at 60Hz"},
+    {
+     quirk_135_clock_too_high, DDC_QUIRK_135_CLOCK_TOO_HIGH,
+     "Recommended 135MHz pixel clock is too high"},
     {
-	quirk_135_clock_too_high,   DDC_QUIRK_135_CLOCK_TOO_HIGH,
-	"Recommended 135MHz pixel clock is too high"
-    },
+     quirk_prefer_large_75, DDC_QUIRK_PREFER_LARGE_75,
+     "Detailed timing is not preferred, use largest mode at 75Hz"},
     {
-	quirk_prefer_large_75,   DDC_QUIRK_PREFER_LARGE_75,
-	"Detailed timing is not preferred, use largest mode at 75Hz"
-    },
+     quirk_detailed_h_in_cm, DDC_QUIRK_DETAILED_H_IN_CM,
+     "Detailed timings give horizontal size in cm."},
     {
-	quirk_detailed_h_in_cm,   DDC_QUIRK_DETAILED_H_IN_CM,
-	"Detailed timings give horizontal size in cm."
-    },
+     quirk_detailed_v_in_cm, DDC_QUIRK_DETAILED_V_IN_CM,
+     "Detailed timings give vertical size in cm."},
     {
-	quirk_detailed_v_in_cm,   DDC_QUIRK_DETAILED_V_IN_CM,
-	"Detailed timings give vertical size in cm."
-    },
+     quirk_detailed_use_maximum_size, DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE,
+     "Use maximum size instead of detailed timing sizes."},
     {
-	quirk_detailed_use_maximum_size,   DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE,
-	"Use maximum size instead of detailed timing sizes."
-    },
+     quirk_first_detailed_preferred, DDC_QUIRK_FIRST_DETAILED_PREFERRED,
+     "First detailed timing was not marked as preferred."},
     {
-	quirk_first_detailed_preferred, DDC_QUIRK_FIRST_DETAILED_PREFERRED,
-	"First detailed timing was not marked as preferred."
-    },
+     quirk_detailed_sync_pp, DDC_QUIRK_DETAILED_SYNC_PP,
+     "Use +hsync +vsync for detailed timing."},
     {
-	quirk_detailed_sync_pp, DDC_QUIRK_DETAILED_SYNC_PP,
-	"Use +hsync +vsync for detailed timing."
-    },
+     quirk_dvi_single_link, DDC_QUIRK_DVI_SINGLE_LINK,
+     "Forcing maximum pixel clock to single DVI link."},
     {
-	quirk_dvi_single_link, DDC_QUIRK_DVI_SINGLE_LINK,
-	"Forcing maximum pixel clock to single DVI link."
-    },
-    { 
-	NULL,		DDC_QUIRK_NONE,
-	"No known quirks"
-    },
+     NULL, DDC_QUIRK_NONE,
+     "No known quirks"},
 };
 
 /*
@@ -289,28 +269,28 @@ static const ddc_quirk_map_t ddc_quirks[] = {
 #define MODESUFFIX 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,FALSE,FALSE,0,NULL,0,0.0,0.0
 
 static const DisplayModeRec DDCEstablishedModes[17] = {
-    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */
-    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */
-    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */
-    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */
-    { MODEPREFIX,    30240,  640,  704,  768,  864, 0,  480,  483,  486,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@67Hz */
-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */
-    { MODEPREFIX,    35500,  720,  738,  846,  900, 0,  400,  421,  423,  449, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 720x400@88Hz */
-    { MODEPREFIX,    28320,  720,  738,  846,  900, 0,  400,  412,  414,  449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@70Hz */
-    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */
-    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */
-    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */
-    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */
-    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz */
-    { MODEPREFIX,    57284,  832,  864,  928, 1152, 0,  624,  625,  628,  667, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 832x624@75Hz */
-    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */
-    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */
-    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */
+    {MODEPREFIX, 40000, 800, 840, 968, 1056, 0, 600, 601, 605, 628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@60Hz */
+    {MODEPREFIX, 36000, 800, 824, 896, 1024, 0, 600, 601, 603, 625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@56Hz */
+    {MODEPREFIX, 31500, 640, 656, 720, 840, 0, 480, 481, 484, 500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@75Hz */
+    {MODEPREFIX, 31500, 640, 664, 704, 832, 0, 480, 489, 492, 520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@72Hz */
+    {MODEPREFIX, 30240, 640, 704, 768, 864, 0, 480, 483, 486, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@67Hz */
+    {MODEPREFIX, 25175, 640, 656, 752, 800, 0, 480, 490, 492, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@60Hz */
+    {MODEPREFIX, 35500, 720, 738, 846, 900, 0, 400, 421, 423, 449, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 720x400@88Hz */
+    {MODEPREFIX, 28320, 720, 738, 846, 900, 0, 400, 412, 414, 449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX}, /* 720x400@70Hz */
+    {MODEPREFIX, 135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1280x1024@75Hz */
+    {MODEPREFIX, 78750, 1024, 1040, 1136, 1312, 0, 768, 769, 772, 800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* 1024x768@75Hz */
+    {MODEPREFIX, 75000, 1024, 1048, 1184, 1328, 0, 768, 771, 777, 806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* 1024x768@70Hz */
+    {MODEPREFIX, 65000, 1024, 1048, 1184, 1344, 0, 768, 771, 777, 806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* 1024x768@60Hz */
+    {MODEPREFIX, 44900, 1024, 1032, 1208, 1264, 0, 768, 768, 772, 817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},       /* 1024x768@43Hz */
+    {MODEPREFIX, 57284, 832, 864, 928, 1152, 0, 624, 625, 628, 667, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},        /* 832x624@75Hz */
+    {MODEPREFIX, 49500, 800, 816, 896, 1056, 0, 600, 601, 604, 625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@75Hz */
+    {MODEPREFIX, 50000, 800, 856, 976, 1040, 0, 600, 637, 643, 666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@72Hz */
+    {MODEPREFIX, 108000, 1152, 1216, 1344, 1600, 0, 864, 865, 868, 900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},    /* 1152x864@75Hz */
 };
 
 static DisplayModePtr
 DDCModesFromEstablished(int scrnIndex, struct established_timings *timing,
-			ddc_quirk_t quirks)
+                        ddc_quirk_t quirks)
 {
     DisplayModePtr Modes = NULL, Mode = NULL;
     CARD32 bits = (timing->t1) | (timing->t2 << 8) |
@@ -329,86 +309,86 @@ DDCModesFromEstablished(int scrnIndex, struct established_timings *timing,
 
 /* Autogenerated from the DMT spec */
 const DisplayModeRec DMTModes[] = {
-    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  350,  382,  385,  445, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x350@85Hz */
-    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  400,  401,  404,  445, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 640x400@85Hz */
-    { MODEPREFIX,    35500,  720,  756,  828,  936, 0,  400,  401,  404,  446, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@85Hz */
-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */
-    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */
-    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */
-    { MODEPREFIX,    36000,  640,  696,  752,  832, 0,  480,  481,  484,  509, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@85Hz */
-    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */
-    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */
-    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */
-    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */
-    { MODEPREFIX,    56250,  800,  832,  896, 1048, 0,  600,  601,  604,  631, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@85Hz */
-    { MODEPREFIX,    73250,  800,  848,  880,  960, 0,  600,  603,  607,  636, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 800x600@120Hz RB */
-    { MODEPREFIX,    33750,  848,  864,  976, 1088, 0,  480,  486,  494,  517, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 848x480@60Hz */
-    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz (interlaced) */
-    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */
-    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */
-    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */
-    { MODEPREFIX,    94500, 1024, 1072, 1168, 1376, 0,  768,  769,  772,  808, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@85Hz */
-    { MODEPREFIX,   115500, 1024, 1072, 1104, 1184, 0,  768,  771,  775,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@120Hz RB */
-    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */
-    { MODEPREFIX,    68250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  790, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@60Hz RB */
-    { MODEPREFIX,    79500, 1280, 1344, 1472, 1664, 0,  768,  771,  778,  798, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@60Hz */
-    { MODEPREFIX,   102250, 1280, 1360, 1488, 1696, 0,  768,  771,  778,  805, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@75Hz */
-    { MODEPREFIX,   117500, 1280, 1360, 1496, 1712, 0,  768,  771,  778,  809, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@85Hz */
-    { MODEPREFIX,   140250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@120Hz RB */
-    { MODEPREFIX,    71000, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  823, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@60Hz RB */
-    { MODEPREFIX,    83500, 1280, 1352, 1480, 1680, 0,  800,  803,  809,  831, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@60Hz */
-    { MODEPREFIX,   106500, 1280, 1360, 1488, 1696, 0,  800,  803,  809,  838, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@75Hz */
-    { MODEPREFIX,   122500, 1280, 1360, 1496, 1712, 0,  800,  803,  809,  843, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@85Hz */
-    { MODEPREFIX,   146250, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  847, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@120Hz RB */
-    { MODEPREFIX,   108000, 1280, 1376, 1488, 1800, 0,  960,  961,  964, 1000, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@60Hz */
-    { MODEPREFIX,   148500, 1280, 1344, 1504, 1728, 0,  960,  961,  964, 1011, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@85Hz */
-    { MODEPREFIX,   175500, 1280, 1328, 1360, 1440, 0,  960,  963,  967, 1017, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x960@120Hz RB */
-    { MODEPREFIX,   108000, 1280, 1328, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@60Hz */
-    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */
-    { MODEPREFIX,   157500, 1280, 1344, 1504, 1728, 0, 1024, 1025, 1028, 1072, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@85Hz */
-    { MODEPREFIX,   187250, 1280, 1328, 1360, 1440, 0, 1024, 1027, 1034, 1084, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x1024@120Hz RB */
-    { MODEPREFIX,    85500, 1360, 1424, 1536, 1792, 0,  768,  771,  777,  795, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1360x768@60Hz */
-    { MODEPREFIX,   148250, 1360, 1408, 1440, 1520, 0,  768,  771,  776,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1360x768@120Hz RB */
-    { MODEPREFIX,   101000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@60Hz RB */
-    { MODEPREFIX,   121750, 1400, 1488, 1632, 1864, 0, 1050, 1053, 1057, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@60Hz */
-    { MODEPREFIX,   156000, 1400, 1504, 1648, 1896, 0, 1050, 1053, 1057, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@75Hz */
-    { MODEPREFIX,   179500, 1400, 1504, 1656, 1912, 0, 1050, 1053, 1057, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@85Hz */
-    { MODEPREFIX,   208000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@120Hz RB */
-    { MODEPREFIX,    88750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  926, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@60Hz RB */
-    { MODEPREFIX,   106500, 1440, 1520, 1672, 1904, 0,  900,  903,  909,  934, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@60Hz */
-    { MODEPREFIX,   136750, 1440, 1536, 1688, 1936, 0,  900,  903,  909,  942, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@75Hz */
-    { MODEPREFIX,   157000, 1440, 1544, 1696, 1952, 0,  900,  903,  909,  948, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@85Hz */
-    { MODEPREFIX,   182750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  953, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@120Hz RB */
-    { MODEPREFIX,   162000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@60Hz */
-    { MODEPREFIX,   175500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@65Hz */
-    { MODEPREFIX,   189000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@70Hz */
-    { MODEPREFIX,   202500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@75Hz */
-    { MODEPREFIX,   229500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@85Hz */
-    { MODEPREFIX,   268250, 1600, 1648, 1680, 1760, 0, 1200, 1203, 1207, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1600x1200@120Hz RB */
-    { MODEPREFIX,   119000, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@60Hz RB */
-    { MODEPREFIX,   146250, 1680, 1784, 1960, 2240, 0, 1050, 1053, 1059, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@60Hz */
-    { MODEPREFIX,   187000, 1680, 1800, 1976, 2272, 0, 1050, 1053, 1059, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@75Hz */
-    { MODEPREFIX,   214750, 1680, 1808, 1984, 2288, 0, 1050, 1053, 1059, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@85Hz */
-    { MODEPREFIX,   245500, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@120Hz RB */
-    { MODEPREFIX,   204750, 1792, 1920, 2120, 2448, 0, 1344, 1345, 1348, 1394, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@60Hz */
-    { MODEPREFIX,   261000, 1792, 1888, 2104, 2456, 0, 1344, 1345, 1348, 1417, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@75Hz */
-    { MODEPREFIX,   333250, 1792, 1840, 1872, 1952, 0, 1344, 1347, 1351, 1423, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1792x1344@120Hz RB */
-    { MODEPREFIX,   218250, 1856, 1952, 2176, 2528, 0, 1392, 1393, 1396, 1439, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@60Hz */
-    { MODEPREFIX,   288000, 1856, 1984, 2208, 2560, 0, 1392, 1393, 1396, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@75Hz */
-    { MODEPREFIX,   356500, 1856, 1904, 1936, 2016, 0, 1392, 1395, 1399, 1474, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1856x1392@120Hz RB */
-    { MODEPREFIX,   154000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1235, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@60Hz RB */
-    { MODEPREFIX,   193250, 1920, 2056, 2256, 2592, 0, 1200, 1203, 1209, 1245, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@60Hz */
-    { MODEPREFIX,   245250, 1920, 2056, 2264, 2608, 0, 1200, 1203, 1209, 1255, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@75Hz */
-    { MODEPREFIX,   281250, 1920, 2064, 2272, 2624, 0, 1200, 1203, 1209, 1262, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@85Hz */
-    { MODEPREFIX,   317000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@120Hz RB */
-    { MODEPREFIX,   234000, 1920, 2048, 2256, 2600, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@60Hz */
-    { MODEPREFIX,   297000, 1920, 2064, 2288, 2640, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@75Hz */
-    { MODEPREFIX,   380500, 1920, 1968, 2000, 2080, 0, 1440, 1443, 1447, 1525, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1440@120Hz RB */
-    { MODEPREFIX,   268500, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1646, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@60Hz RB */
-    { MODEPREFIX,   348500, 2560, 2752, 3032, 3504, 0, 1600, 1603, 1609, 1658, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@60Hz */
-    { MODEPREFIX,   443250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1672, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@75Hz */
-    { MODEPREFIX,   505250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1682, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@85Hz */
-    { MODEPREFIX,   552750, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1694, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@120Hz RB */
+    {MODEPREFIX, 31500, 640, 672, 736, 832, 0, 350, 382, 385, 445, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x350@85Hz */
+    {MODEPREFIX, 31500, 640, 672, 736, 832, 0, 400, 401, 404, 445, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX}, /* 640x400@85Hz */
+    {MODEPREFIX, 35500, 720, 756, 828, 936, 0, 400, 401, 404, 446, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX}, /* 720x400@85Hz */
+    {MODEPREFIX, 25175, 640, 656, 752, 800, 0, 480, 490, 492, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@60Hz */
+    {MODEPREFIX, 31500, 640, 664, 704, 832, 0, 480, 489, 492, 520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@72Hz */
+    {MODEPREFIX, 31500, 640, 656, 720, 840, 0, 480, 481, 484, 500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@75Hz */
+    {MODEPREFIX, 36000, 640, 696, 752, 832, 0, 480, 481, 484, 509, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* 640x480@85Hz */
+    {MODEPREFIX, 36000, 800, 824, 896, 1024, 0, 600, 601, 603, 625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@56Hz */
+    {MODEPREFIX, 40000, 800, 840, 968, 1056, 0, 600, 601, 605, 628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@60Hz */
+    {MODEPREFIX, 50000, 800, 856, 976, 1040, 0, 600, 637, 643, 666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@72Hz */
+    {MODEPREFIX, 49500, 800, 816, 896, 1056, 0, 600, 601, 604, 625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@75Hz */
+    {MODEPREFIX, 56250, 800, 832, 896, 1048, 0, 600, 601, 604, 631, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 800x600@85Hz */
+    {MODEPREFIX, 73250, 800, 848, 880, 960, 0, 600, 603, 607, 636, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX}, /* 800x600@120Hz RB */
+    {MODEPREFIX, 33750, 848, 864, 976, 1088, 0, 480, 486, 494, 517, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 848x480@60Hz */
+    {MODEPREFIX, 44900, 1024, 1032, 1208, 1264, 0, 768, 768, 772, 817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},       /* 1024x768@43Hz (interlaced) */
+    {MODEPREFIX, 65000, 1024, 1048, 1184, 1344, 0, 768, 771, 777, 806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* 1024x768@60Hz */
+    {MODEPREFIX, 75000, 1024, 1048, 1184, 1328, 0, 768, 771, 777, 806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* 1024x768@70Hz */
+    {MODEPREFIX, 78750, 1024, 1040, 1136, 1312, 0, 768, 769, 772, 800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* 1024x768@75Hz */
+    {MODEPREFIX, 94500, 1024, 1072, 1168, 1376, 0, 768, 769, 772, 808, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* 1024x768@85Hz */
+    {MODEPREFIX, 115500, 1024, 1072, 1104, 1184, 0, 768, 771, 775, 813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},    /* 1024x768@120Hz RB */
+    {MODEPREFIX, 108000, 1152, 1216, 1344, 1600, 0, 864, 865, 868, 900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},    /* 1152x864@75Hz */
+    {MODEPREFIX, 68250, 1280, 1328, 1360, 1440, 0, 768, 771, 778, 790, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},     /* 1280x768@60Hz RB */
+    {MODEPREFIX, 79500, 1280, 1344, 1472, 1664, 0, 768, 771, 778, 798, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},     /* 1280x768@60Hz */
+    {MODEPREFIX, 102250, 1280, 1360, 1488, 1696, 0, 768, 771, 778, 805, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1280x768@75Hz */
+    {MODEPREFIX, 117500, 1280, 1360, 1496, 1712, 0, 768, 771, 778, 809, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1280x768@85Hz */
+    {MODEPREFIX, 140250, 1280, 1328, 1360, 1440, 0, 768, 771, 778, 813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},    /* 1280x768@120Hz RB */
+    {MODEPREFIX, 71000, 1280, 1328, 1360, 1440, 0, 800, 803, 809, 823, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},     /* 1280x800@60Hz RB */
+    {MODEPREFIX, 83500, 1280, 1352, 1480, 1680, 0, 800, 803, 809, 831, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},     /* 1280x800@60Hz */
+    {MODEPREFIX, 106500, 1280, 1360, 1488, 1696, 0, 800, 803, 809, 838, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1280x800@75Hz */
+    {MODEPREFIX, 122500, 1280, 1360, 1496, 1712, 0, 800, 803, 809, 843, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1280x800@85Hz */
+    {MODEPREFIX, 146250, 1280, 1328, 1360, 1440, 0, 800, 803, 809, 847, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},    /* 1280x800@120Hz RB */
+    {MODEPREFIX, 108000, 1280, 1376, 1488, 1800, 0, 960, 961, 964, 1000, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},   /* 1280x960@60Hz */
+    {MODEPREFIX, 148500, 1280, 1344, 1504, 1728, 0, 960, 961, 964, 1011, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},   /* 1280x960@85Hz */
+    {MODEPREFIX, 175500, 1280, 1328, 1360, 1440, 0, 960, 963, 967, 1017, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},   /* 1280x960@120Hz RB */
+    {MODEPREFIX, 108000, 1280, 1328, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1280x1024@60Hz */
+    {MODEPREFIX, 135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1280x1024@75Hz */
+    {MODEPREFIX, 157500, 1280, 1344, 1504, 1728, 0, 1024, 1025, 1028, 1072, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1280x1024@85Hz */
+    {MODEPREFIX, 187250, 1280, 1328, 1360, 1440, 0, 1024, 1027, 1034, 1084, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1280x1024@120Hz RB */
+    {MODEPREFIX, 85500, 1360, 1424, 1536, 1792, 0, 768, 771, 777, 795, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* 1360x768@60Hz */
+    {MODEPREFIX, 148250, 1360, 1408, 1440, 1520, 0, 768, 771, 776, 813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},    /* 1360x768@120Hz RB */
+    {MODEPREFIX, 101000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1400x1050@60Hz RB */
+    {MODEPREFIX, 121750, 1400, 1488, 1632, 1864, 0, 1050, 1053, 1057, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1400x1050@60Hz */
+    {MODEPREFIX, 156000, 1400, 1504, 1648, 1896, 0, 1050, 1053, 1057, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1400x1050@75Hz */
+    {MODEPREFIX, 179500, 1400, 1504, 1656, 1912, 0, 1050, 1053, 1057, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1400x1050@85Hz */
+    {MODEPREFIX, 208000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1400x1050@120Hz RB */
+    {MODEPREFIX, 88750, 1440, 1488, 1520, 1600, 0, 900, 903, 909, 926, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},     /* 1440x900@60Hz RB */
+    {MODEPREFIX, 106500, 1440, 1520, 1672, 1904, 0, 900, 903, 909, 934, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1440x900@60Hz */
+    {MODEPREFIX, 136750, 1440, 1536, 1688, 1936, 0, 900, 903, 909, 942, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1440x900@75Hz */
+    {MODEPREFIX, 157000, 1440, 1544, 1696, 1952, 0, 900, 903, 909, 948, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},    /* 1440x900@85Hz */
+    {MODEPREFIX, 182750, 1440, 1488, 1520, 1600, 0, 900, 903, 909, 953, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},    /* 1440x900@120Hz RB */
+    {MODEPREFIX, 162000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1600x1200@60Hz */
+    {MODEPREFIX, 175500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1600x1200@65Hz */
+    {MODEPREFIX, 189000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1600x1200@70Hz */
+    {MODEPREFIX, 202500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1600x1200@75Hz */
+    {MODEPREFIX, 229500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* 1600x1200@85Hz */
+    {MODEPREFIX, 268250, 1600, 1648, 1680, 1760, 0, 1200, 1203, 1207, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1600x1200@120Hz RB */
+    {MODEPREFIX, 119000, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1680x1050@60Hz RB */
+    {MODEPREFIX, 146250, 1680, 1784, 1960, 2240, 0, 1050, 1053, 1059, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1680x1050@60Hz */
+    {MODEPREFIX, 187000, 1680, 1800, 1976, 2272, 0, 1050, 1053, 1059, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1680x1050@75Hz */
+    {MODEPREFIX, 214750, 1680, 1808, 1984, 2288, 0, 1050, 1053, 1059, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1680x1050@85Hz */
+    {MODEPREFIX, 245500, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1680x1050@120Hz RB */
+    {MODEPREFIX, 204750, 1792, 1920, 2120, 2448, 0, 1344, 1345, 1348, 1394, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1792x1344@60Hz */
+    {MODEPREFIX, 261000, 1792, 1888, 2104, 2456, 0, 1344, 1345, 1348, 1417, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1792x1344@75Hz */
+    {MODEPREFIX, 333250, 1792, 1840, 1872, 1952, 0, 1344, 1347, 1351, 1423, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1792x1344@120Hz RB */
+    {MODEPREFIX, 218250, 1856, 1952, 2176, 2528, 0, 1392, 1393, 1396, 1439, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1856x1392@60Hz */
+    {MODEPREFIX, 288000, 1856, 1984, 2208, 2560, 0, 1392, 1393, 1396, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1856x1392@75Hz */
+    {MODEPREFIX, 356500, 1856, 1904, 1936, 2016, 0, 1392, 1395, 1399, 1474, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1856x1392@120Hz RB */
+    {MODEPREFIX, 154000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1235, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1920x1200@60Hz RB */
+    {MODEPREFIX, 193250, 1920, 2056, 2256, 2592, 0, 1200, 1203, 1209, 1245, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1920x1200@60Hz */
+    {MODEPREFIX, 245250, 1920, 2056, 2264, 2608, 0, 1200, 1203, 1209, 1255, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1920x1200@75Hz */
+    {MODEPREFIX, 281250, 1920, 2064, 2272, 2624, 0, 1200, 1203, 1209, 1262, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1920x1200@85Hz */
+    {MODEPREFIX, 317000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1920x1200@120Hz RB */
+    {MODEPREFIX, 234000, 1920, 2048, 2256, 2600, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1920x1440@60Hz */
+    {MODEPREFIX, 297000, 1920, 2064, 2288, 2640, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 1920x1440@75Hz */
+    {MODEPREFIX, 380500, 1920, 1968, 2000, 2080, 0, 1440, 1443, 1447, 1525, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 1920x1440@120Hz RB */
+    {MODEPREFIX, 268500, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1646, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 2560x1600@60Hz RB */
+    {MODEPREFIX, 348500, 2560, 2752, 3032, 3504, 0, 1600, 1603, 1609, 1658, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 2560x1600@60Hz */
+    {MODEPREFIX, 443250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1672, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 2560x1600@75Hz */
+    {MODEPREFIX, 505250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1682, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX},        /* 2560x1600@85Hz */
+    {MODEPREFIX, 552750, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1694, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX},        /* 2560x1600@120Hz RB */
 };
 
 #define LEVEL_DMT 0
@@ -419,18 +399,18 @@ static int
 MonitorStandardTimingLevel(xf86MonPtr DDC)
 {
     if (DDC->ver.revision >= 2) {
-	if (DDC->ver.revision >= 4 && CVT_SUPPORTED(DDC->features.msc)) {
-	    return LEVEL_CVT;
-	}
-	return LEVEL_GTF;
+        if (DDC->ver.revision >= 4 && CVT_SUPPORTED(DDC->features.msc)) {
+            return LEVEL_CVT;
+        }
+        return LEVEL_GTF;
     }
     return LEVEL_DMT;
 }
 
 static int
-ModeRefresh(const DisplayModeRec *mode)
+ModeRefresh(const DisplayModeRec * mode)
 {
-    return (int)(xf86ModeVRefresh(mode) + 0.5);
+    return (int) (xf86ModeVRefresh(mode) + 0.5);
 }
 
 /*
@@ -445,15 +425,14 @@ FindDMTMode(int hsize, int vsize, int refresh, Bool rb)
     const DisplayModeRec *ret;
 
     for (i = 0; i < sizeof(DMTModes) / sizeof(DisplayModeRec); i++) {
-	ret = &DMTModes[i];
+        ret = &DMTModes[i];
 
-	if (!rb && xf86ModeIsReduced(ret))
-	    continue;
+        if (!rb && xf86ModeIsReduced(ret))
+            continue;
 
-	if (ret->HDisplay == hsize &&
-	    ret->VDisplay == vsize &&
-	    refresh == ModeRefresh(ret))
-	    return xf86DuplicateMode(ret);
+        if (ret->HDisplay == hsize &&
+            ret->VDisplay == vsize && refresh == ModeRefresh(ret))
+            return xf86DuplicateMode(ret);
     }
 
     return NULL;
@@ -478,42 +457,43 @@ FindDMTMode(int hsize, int vsize, int refresh, Bool rb)
  */
 static DisplayModePtr
 DDCModesFromStandardTiming(struct std_timings *timing, ddc_quirk_t quirks,
-			   int timing_level, Bool rb)
+                           int timing_level, Bool rb)
 {
     DisplayModePtr Modes = NULL, Mode = NULL;
     int i, hsize, vsize, refresh;
 
     for (i = 0; i < STD_TIMINGS; i++) {
-	hsize = timing[i].hsize;
-	vsize = timing[i].vsize;
-	refresh = timing[i].refresh;
-
-	/* HDTV hack, because you can't say 1366 */
-	if (refresh == 60 &&
-	    ((hsize == 1360 && vsize == 765) ||
-	     (hsize == 1368 && vsize == 769))) {
-	    Mode = xf86CVTMode(1366, 768, 60, FALSE, FALSE);
-	    Mode->HDisplay = 1366;
-	    Mode->HSyncStart--;
-	    Mode->HSyncEnd--;
-	} else if (hsize && vsize && refresh) {
-	    Mode = FindDMTMode(hsize, vsize, refresh, rb);
-
-	    if (!Mode) {
-		if (timing_level == LEVEL_CVT)
-		    /* pass rb here too? */
-		    Mode = xf86CVTMode(hsize, vsize, refresh, FALSE, FALSE);
-		else if (timing_level == LEVEL_GTF)
-		    Mode = xf86GTFMode(hsize, vsize, refresh, FALSE, FALSE);
-	    }
-
-	}
-
-	if (Mode) {
-	    Mode->type = M_T_DRIVER;
-	    Modes = xf86ModesAdd(Modes, Mode);
-	}
-	Mode = NULL;
+        hsize = timing[i].hsize;
+        vsize = timing[i].vsize;
+        refresh = timing[i].refresh;
+
+        /* HDTV hack, because you can't say 1366 */
+        if (refresh == 60 &&
+            ((hsize == 1360 && vsize == 765) ||
+             (hsize == 1368 && vsize == 769))) {
+            Mode = xf86CVTMode(1366, 768, 60, FALSE, FALSE);
+            Mode->HDisplay = 1366;
+            Mode->HSyncStart--;
+            Mode->HSyncEnd--;
+        }
+        else if (hsize && vsize && refresh) {
+            Mode = FindDMTMode(hsize, vsize, refresh, rb);
+
+            if (!Mode) {
+                if (timing_level == LEVEL_CVT)
+                    /* pass rb here too? */
+                    Mode = xf86CVTMode(hsize, vsize, refresh, FALSE, FALSE);
+                else if (timing_level == LEVEL_GTF)
+                    Mode = xf86GTFMode(hsize, vsize, refresh, FALSE, FALSE);
+            }
+
+        }
+
+        if (Mode) {
+            Mode->type = M_T_DRIVER;
+            Modes = xf86ModesAdd(Modes, Mode);
+        }
+        Mode = NULL;
     }
 
     return Modes;
@@ -531,28 +511,29 @@ DDCModeDoInterlaceQuirks(DisplayModePtr mode)
      * should be checking refresh rate too.  Whatever.
      */
     static const struct {
-	int w, h;
+        int w, h;
     } cea_interlaced[] = {
-	{ 1920, 1080 },
-	{  720,  480 },
-	{ 1440,  480 },
-	{ 2880,  480 },
-	{  720,  576 },
-	{ 1440,  576 },
-	{ 2880,  576 },
-    };
-    static const int n_modes = sizeof(cea_interlaced)/sizeof(cea_interlaced[0]);
+        {
+        1920, 1080}, {
+        720, 480}, {
+        1440, 480}, {
+        2880, 480}, {
+        720, 576}, {
+        1440, 576}, {
+    2880, 576},};
+    static const int n_modes =
+        sizeof(cea_interlaced) / sizeof(cea_interlaced[0]);
     int i;
 
     for (i = 0; i < n_modes; i++) {
-	if ((mode->HDisplay == cea_interlaced[i].w) &&
-	    (mode->VDisplay == cea_interlaced[i].h / 2)) {
-	    mode->VDisplay *= 2;
-	    mode->VSyncStart *= 2;
-	    mode->VSyncEnd *= 2;
-	    mode->VTotal *= 2;
-	    mode->VTotal |= 1;
-	}
+        if ((mode->HDisplay == cea_interlaced[i].w) &&
+            (mode->VDisplay == cea_interlaced[i].h / 2)) {
+            mode->VDisplay *= 2;
+            mode->VSyncStart *= 2;
+            mode->VSyncEnd *= 2;
+            mode->VTotal *= 2;
+            mode->VTotal |= 1;
+        }
     }
 
     mode->Flags |= V_INTERLACE;
@@ -563,7 +544,7 @@ DDCModeDoInterlaceQuirks(DisplayModePtr mode)
  */
 static DisplayModePtr
 DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,
-			  Bool preferred, ddc_quirk_t quirks)
+                          Bool preferred, ddc_quirk_t quirks)
 {
     DisplayModePtr Mode;
 
@@ -574,34 +555,33 @@ DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,
      * our parser is just being too aggresive there.
      */
     if (timing->h_active < 64 || timing->v_active < 64) {
-	xf86DrvMsg(scrnIndex, X_INFO,
-		   "%s: Ignoring tiny %dx%d mode\n", __func__,
-		   timing->h_active, timing->v_active);
-	return NULL;
+        xf86DrvMsg(scrnIndex, X_INFO,
+                   "%s: Ignoring tiny %dx%d mode\n", __func__,
+                   timing->h_active, timing->v_active);
+        return NULL;
     }
 
     /* We don't do stereo */
     if (timing->stereo) {
         xf86DrvMsg(scrnIndex, X_INFO,
-		   "%s: Ignoring: We don't handle stereo.\n", __func__);
+                   "%s: Ignoring: We don't handle stereo.\n", __func__);
         return NULL;
     }
 
     /* We only do seperate sync currently */
     if (timing->sync != 0x03) {
-         xf86DrvMsg(scrnIndex, X_INFO,
-		    "%s: %dx%d Warning: We only handle separate"
-                    " sync.\n", __func__, timing->h_active, timing->v_active);
+        xf86DrvMsg(scrnIndex, X_INFO,
+                   "%s: %dx%d Warning: We only handle separate"
+                   " sync.\n", __func__, timing->h_active, timing->v_active);
     }
 
     Mode = xnfcalloc(1, sizeof(DisplayModeRec));
 
     Mode->type = M_T_DRIVER;
     if (preferred)
-	Mode->type |= M_T_PREFERRED;
+        Mode->type |= M_T_PREFERRED;
 
-    if( ( quirks & DDC_QUIRK_135_CLOCK_TOO_HIGH ) &&
-	timing->clock == 135000000 )
+    if ((quirks & DDC_QUIRK_135_CLOCK_TOO_HIGH) && timing->clock == 135000000)
         Mode->Clock = 108880;
     else
         Mode->Clock = timing->clock / 1000.0;
@@ -618,27 +598,27 @@ DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,
 
     /* perform basic check on the detail timing */
     if (Mode->HSyncEnd > Mode->HTotal || Mode->VSyncEnd > Mode->VTotal) {
-	free(Mode);
-	return NULL;
+        free(Mode);
+        return NULL;
     }
 
     /* We ignore h/v_size and h/v_border for now. */
 
     if (timing->interlaced)
-	DDCModeDoInterlaceQuirks(Mode);
+        DDCModeDoInterlaceQuirks(Mode);
 
     if (quirks & DDC_QUIRK_DETAILED_SYNC_PP)
-	Mode->Flags |= V_PVSYNC | V_PHSYNC;
+        Mode->Flags |= V_PVSYNC | V_PHSYNC;
     else {
-	if (timing->misc & 0x02)
-	    Mode->Flags |= V_PVSYNC;
-	else
-	    Mode->Flags |= V_NVSYNC;
-
-	if (timing->misc & 0x01)
-	    Mode->Flags |= V_PHSYNC;
-	else
-	    Mode->Flags |= V_NHSYNC;
+        if (timing->misc & 0x02)
+            Mode->Flags |= V_PVSYNC;
+        else
+            Mode->Flags |= V_NVSYNC;
+
+        if (timing->misc & 0x01)
+            Mode->Flags |= V_PHSYNC;
+        else
+            Mode->Flags |= V_NHSYNC;
     }
 
     xf86SetModeDefaultName(Mode);
@@ -653,23 +633,30 @@ DDCModesFromCVT(int scrnIndex, struct cvt_timings *t)
     int i;
 
     for (i = 0; i < 4; i++) {
-	if (t[i].height) {
-	    if (t[i].rates & 0x10)
-		modes = xf86ModesAdd(modes,
-			xf86CVTMode(t[i].width, t[i].height, 50, 0, 0));
-	    if (t[i].rates & 0x08)
-		modes = xf86ModesAdd(modes,
-			xf86CVTMode(t[i].width, t[i].height, 60, 0, 0));
-	    if (t[i].rates & 0x04)
-		modes = xf86ModesAdd(modes,
-			xf86CVTMode(t[i].width, t[i].height, 75, 0, 0));
-	    if (t[i].rates & 0x02)
-		modes = xf86ModesAdd(modes,
-			xf86CVTMode(t[i].width, t[i].height, 85, 0, 0));
-	    if (t[i].rates & 0x01)
-		modes = xf86ModesAdd(modes,
-			xf86CVTMode(t[i].width, t[i].height, 60, 1, 0));
-	} else break;
+        if (t[i].height) {
+            if (t[i].rates & 0x10)
+                modes = xf86ModesAdd(modes,
+                                     xf86CVTMode(t[i].width, t[i].height, 50, 0,
+                                                 0));
+            if (t[i].rates & 0x08)
+                modes = xf86ModesAdd(modes,
+                                     xf86CVTMode(t[i].width, t[i].height, 60, 0,
+                                                 0));
+            if (t[i].rates & 0x04)
+                modes = xf86ModesAdd(modes,
+                                     xf86CVTMode(t[i].width, t[i].height, 75, 0,
+                                                 0));
+            if (t[i].rates & 0x02)
+                modes = xf86ModesAdd(modes,
+                                     xf86CVTMode(t[i].width, t[i].height, 85, 0,
+                                                 0));
+            if (t[i].rates & 0x01)
+                modes = xf86ModesAdd(modes,
+                                     xf86CVTMode(t[i].width, t[i].height, 60, 1,
+                                                 0));
+        }
+        else
+            break;
     }
 
     return modes;
@@ -682,56 +669,61 @@ static const struct {
     short rb;
 } EstIIIModes[] = {
     /* byte 6 */
-    { 640, 350, 85, 0 },
-    { 640, 400, 85, 0 },
-    { 720, 400, 85, 0 },
-    { 640, 480, 85, 0 },
-    { 848, 480, 60, 0 },
-    { 800, 600, 85, 0 },
-    { 1024, 768, 85, 0 },
-    { 1152, 864, 75, 0 },
-    /* byte 7 */
-    { 1280, 768, 60, 1 },
-    { 1280, 768, 60, 0 },
-    { 1280, 768, 75, 0 },
-    { 1280, 768, 85, 0 },
-    { 1280, 960, 60, 0 },
-    { 1280, 960, 85, 0 },
-    { 1280, 1024, 60, 0 },
-    { 1280, 1024, 85, 0 },
-    /* byte 8 */
-    { 1360, 768, 60, 0 },
-    { 1440, 900, 60, 1 },
-    { 1440, 900, 60, 0 },
-    { 1440, 900, 75, 0 },
-    { 1440, 900, 85, 0 },
-    { 1400, 1050, 60, 1 },
-    { 1400, 1050, 60, 0 },
-    { 1400, 1050, 75, 0 },
-    /* byte 9 */
-    { 1400, 1050, 85, 0 },
-    { 1680, 1050, 60, 1 },
-    { 1680, 1050, 60, 0 },
-    { 1680, 1050, 75, 0 },
-    { 1680, 1050, 85, 0 },
-    { 1600, 1200, 60, 0 },
-    { 1600, 1200, 65, 0 },
-    { 1600, 1200, 70, 0 },
-    /* byte 10 */
-    { 1600, 1200, 75, 0 },
-    { 1600, 1200, 85, 0 },
-    { 1792, 1344, 60, 0 },
-    { 1792, 1344, 85, 0 },
-    { 1856, 1392, 60, 0 },
-    { 1856, 1392, 75, 0 },
-    { 1920, 1200, 60, 1 },
-    { 1920, 1200, 60, 0 },
-    /* byte 11 */
-    { 1920, 1200, 75, 0 },
-    { 1920, 1200, 85, 0 },
-    { 1920, 1440, 60, 0 },
-    { 1920, 1440, 75, 0 },
-};
+    {
+    640, 350, 85, 0}, {
+    640, 400, 85, 0}, {
+    720, 400, 85, 0}, {
+    640, 480, 85, 0}, {
+    848, 480, 60, 0}, {
+    800, 600, 85, 0}, {
+    1024, 768, 85, 0}, {
+    1152, 864, 75, 0},
+        /* byte 7 */
+    {
+    1280, 768, 60, 1}, {
+    1280, 768, 60, 0}, {
+    1280, 768, 75, 0}, {
+    1280, 768, 85, 0}, {
+    1280, 960, 60, 0}, {
+    1280, 960, 85, 0}, {
+    1280, 1024, 60, 0}, {
+    1280, 1024, 85, 0},
+        /* byte 8 */
+    {
+    1360, 768, 60, 0}, {
+    1440, 900, 60, 1}, {
+    1440, 900, 60, 0}, {
+    1440, 900, 75, 0}, {
+    1440, 900, 85, 0}, {
+    1400, 1050, 60, 1}, {
+    1400, 1050, 60, 0}, {
+    1400, 1050, 75, 0},
+        /* byte 9 */
+    {
+    1400, 1050, 85, 0}, {
+    1680, 1050, 60, 1}, {
+    1680, 1050, 60, 0}, {
+    1680, 1050, 75, 0}, {
+    1680, 1050, 85, 0}, {
+    1600, 1200, 60, 0}, {
+    1600, 1200, 65, 0}, {
+    1600, 1200, 70, 0},
+        /* byte 10 */
+    {
+    1600, 1200, 75, 0}, {
+    1600, 1200, 85, 0}, {
+    1792, 1344, 60, 0}, {
+    1792, 1344, 85, 0}, {
+    1856, 1392, 60, 0}, {
+    1856, 1392, 75, 0}, {
+    1920, 1200, 60, 1}, {
+    1920, 1200, 60, 0},
+        /* byte 11 */
+    {
+    1920, 1200, 75, 0}, {
+    1920, 1200, 85, 0}, {
+    1920, 1440, 60, 0}, {
+1920, 1440, 75, 0},};
 
 static DisplayModePtr
 DDCModesFromEstIII(unsigned char *est)
@@ -740,16 +732,16 @@ DDCModesFromEstIII(unsigned char *est)
     int i, j, m;
 
     for (i = 0; i < 6; i++) {
-	for (j = 7; j > 0; j--) {
-	    if (est[i] & (1 << j)) {
-		m = (i * 8) + (7 - j);
-		modes = xf86ModesAdd(modes,
-				     FindDMTMode(EstIIIModes[m].w,
-						 EstIIIModes[m].h,
-						 EstIIIModes[m].r,
-						 EstIIIModes[m].rb));
-	    }
-	}
+        for (j = 7; j > 0; j--) {
+            if (est[i] & (1 << j)) {
+                m = (i * 8) + (7 - j);
+                modes = xf86ModesAdd(modes,
+                                     FindDMTMode(EstIIIModes[m].w,
+                                                 EstIIIModes[m].h,
+                                                 EstIIIModes[m].r,
+                                                 EstIIIModes[m].rb));
+            }
+        }
     }
 
     return modes;
@@ -781,10 +773,10 @@ DDCGuessRangesFromModes(int scrnIndex, MonPtr Monitor, DisplayModePtr Modes)
 
     while (Mode) {
         if (!Mode->HSync)
-            Mode->HSync = ((float) Mode->Clock ) / ((float) Mode->HTotal);
+            Mode->HSync = ((float) Mode->Clock) / ((float) Mode->HTotal);
 
         if (!Mode->VRefresh)
-            Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) / 
+            Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) /
                 ((float) (Mode->HTotal * Mode->VTotal));
 
         if (Mode->HSync < Monitor->hsync[0].lo)
@@ -806,26 +798,26 @@ DDCGuessRangesFromModes(int scrnIndex, MonPtr Monitor, DisplayModePtr Modes)
 ddc_quirk_t
 xf86DDCDetectQuirks(int scrnIndex, xf86MonPtr DDC, Bool verbose)
 {
-    ddc_quirk_t	quirks;
+    ddc_quirk_t quirks;
     int i;
 
     quirks = DDC_QUIRK_NONE;
     for (i = 0; ddc_quirks[i].detect; i++) {
-	if (ddc_quirks[i].detect (scrnIndex, DDC)) {
-	    if (verbose) {
-		xf86DrvMsg (scrnIndex, X_INFO, "    EDID quirk: %s\n",
-			    ddc_quirks[i].description);
-	    }
-	    quirks |= ddc_quirks[i].quirk;
-	}
+        if (ddc_quirks[i].detect(scrnIndex, DDC)) {
+            if (verbose) {
+                xf86DrvMsg(scrnIndex, X_INFO, "    EDID quirk: %s\n",
+                           ddc_quirks[i].description);
+            }
+            quirks |= ddc_quirks[i].quirk;
+        }
     }
 
     return quirks;
 }
 
-void xf86DetTimingApplyQuirks(struct detailed_monitor_section *det_mon,
-                              ddc_quirk_t quirks,
-                              int hsize, int vsize)
+void
+xf86DetTimingApplyQuirks(struct detailed_monitor_section *det_mon,
+                         ddc_quirk_t quirks, int hsize, int vsize)
 {
     if (det_mon->type != DT)
         return;
@@ -851,13 +843,12 @@ void xf86DetTimingApplyQuirks(struct detailed_monitor_section *det_mon,
 void
 xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC)
 {
-    ddc_quirk_t quirks = xf86DDCDetectQuirks (scrnIndex, DDC, FALSE);
+    ddc_quirk_t quirks = xf86DDCDetectQuirks(scrnIndex, DDC, FALSE);
     int i;
 
     for (i = 0; i < DET_TIMINGS; i++) {
         xf86DetTimingApplyQuirks(DDC->det_mon + i, quirks,
-                                 DDC->features.hsize,
-                                 DDC->features.vsize);
+                                 DDC->features.hsize, DDC->features.vsize);
     }
 }
 
@@ -867,120 +858,116 @@ xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC)
 */
 static void
 xf86DDCSetPreferredRefresh(int scrnIndex, DisplayModePtr modes,
-			   float target_refresh)
+                           float target_refresh)
 {
-	DisplayModePtr	mode, best = modes;
-
-	for (mode = modes; mode; mode = mode->next)
-	{
-	    mode->type &= ~M_T_PREFERRED;
-
-	    if (mode == best) continue;
-
-	    if (mode->HDisplay * mode->VDisplay >
-		best->HDisplay * best->VDisplay)
-	    {
-		best = mode;
-		continue;
-	    }
-	    if (mode->HDisplay * mode->VDisplay ==
-		best->HDisplay * best->VDisplay)
-	    {
-		double	mode_refresh = xf86ModeVRefresh (mode);
-		double	best_refresh = xf86ModeVRefresh (best);
-		double	mode_dist = fabs(mode_refresh - target_refresh);
-		double	best_dist = fabs(best_refresh - target_refresh);
-
-		if (mode_dist < best_dist)
-		{
-		    best = mode;
-		    continue;
-		}
-	    }
-	}
-	if (best)
-	    best->type |= M_T_PREFERRED;
+    DisplayModePtr mode, best = modes;
+
+    for (mode = modes; mode; mode = mode->next) {
+        mode->type &= ~M_T_PREFERRED;
+
+        if (mode == best)
+            continue;
+
+        if (mode->HDisplay * mode->VDisplay > best->HDisplay * best->VDisplay) {
+            best = mode;
+            continue;
+        }
+        if (mode->HDisplay * mode->VDisplay == best->HDisplay * best->VDisplay) {
+            double mode_refresh = xf86ModeVRefresh(mode);
+            double best_refresh = xf86ModeVRefresh(best);
+            double mode_dist = fabs(mode_refresh - target_refresh);
+            double best_dist = fabs(best_refresh - target_refresh);
+
+            if (mode_dist < best_dist) {
+                best = mode;
+                continue;
+            }
+        }
+    }
+    if (best)
+        best->type |= M_T_PREFERRED;
 }
 
 #define CEA_VIDEO_MODES_NUM  64
 static const DisplayModeRec CEAVideoModes[CEA_VIDEO_MODES_NUM] = {
-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 1:640x480@60Hz */
-    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 2:720x480@60Hz */
-    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 3:720x480@60Hz */
-    { MODEPREFIX,    74250, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 4: 1280x720@60Hz */
-    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 5:1920x1080i@60Hz */
-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 6:1440x480i@60Hz */
-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 7:1440x480i@60Hz */
-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 8:1440x240@60Hz */
-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 9:1440x240@60Hz */
-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 10:2880x480i@60Hz */
-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 11:2880x480i@60Hz */
-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 12:2880x240@60Hz */
-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 13:2880x240@60Hz */
-    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 14:1440x480@60Hz */
-    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 15:1440x480@60Hz */
-    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 16:1920x1080@60Hz */
-    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 17:720x576@50Hz */
-    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 18:720x576@50Hz */
-    { MODEPREFIX,    74250, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 19: 1280x720@50Hz */
-    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 20:1920x1080i@50Hz */
-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 21:1440x576i@50Hz */
-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 22:1440x576i@50Hz */
-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 23:1440x288@50Hz */
-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 24:1440x288@50Hz */
-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 25:2880x576i@50Hz */
-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 26:2880x576i@50Hz */
-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 27:2880x288@50Hz */
-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 28:2880x288@50Hz */
-    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 29:1440x576@50Hz */
-    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 30:1440x576@50Hz */
-    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 31:1920x1080@50Hz */
-    { MODEPREFIX,    74250, 1920, 2558, 2602, 2750, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 32:1920x1080@24Hz */
-    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 33:1920x1080@25Hz */
-    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 34:1920x1080@30Hz */
-    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 35:2880x480@60Hz */
-    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 36:2880x480@60Hz */
-    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 37:2880x576@50Hz */
-    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 38:2880x576@50Hz */
-    { MODEPREFIX,    72000, 1920, 1952, 2120, 2304, 0, 1080, 1126, 1136, 1250, 0, V_PHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 39:1920x1080i@50Hz */
-    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 40:1920x1080i@100Hz */
-    { MODEPREFIX,   148500, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 41:1280x720@100Hz */
-    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 42:720x576@100Hz */
-    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 43:720x576@100Hz */
-    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 44:1440x576i@100Hz */
-    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 45:1440x576i@100Hz */
-    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 46:1920x1080i@120Hz */
-    { MODEPREFIX,   148500, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 47:1280x720@120Hz */
-    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 48:720x480@120Hz */
-    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 49:720x480@120Hz */
-    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 50:1440x480i@120Hz */
-    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 51:1440x480i@120Hz */
-    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 52:720x576@200Hz */
-    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 53:720x576@200Hz */
-    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 54:1440x576i@200Hz */
-    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 55:1440x576i@200Hz */
-    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 56:720x480@240Hz */
-    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 57:720x480@240Hz */
-    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 58:1440x480i@240 */
-    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 59:1440x480i@240 */
-    { MODEPREFIX,    59400, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 60: 1280x720@24Hz */
-    { MODEPREFIX,    74250, 1280, 3700, 3740, 3960, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 61: 1280x720@25Hz */
-    { MODEPREFIX,    74250, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 62: 1280x720@30Hz */
-    { MODEPREFIX,   297000, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 63: 1920x1080@120Hz */
-    { MODEPREFIX,   297000, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 64:1920x1080@100Hz */
+    {MODEPREFIX, 25175, 640, 656, 752, 800, 0, 480, 490, 492, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 1:640x480@60Hz */
+    {MODEPREFIX, 27000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 2:720x480@60Hz */
+    {MODEPREFIX, 27000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 3:720x480@60Hz */
+    {MODEPREFIX, 74250, 1280, 1390, 1430, 1650, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* VIC 4: 1280x720@60Hz */
+    {MODEPREFIX, 74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},   /* VIC 5:1920x1080i@60Hz */
+    {MODEPREFIX, 27000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 6:1440x480i@60Hz */
+    {MODEPREFIX, 27000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 7:1440x480i@60Hz */
+    {MODEPREFIX, 27000, 1440, 1478, 1602, 1716, 0, 240, 244, 247, 262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 8:1440x240@60Hz */
+    {MODEPREFIX, 27000, 1440, 1478, 1602, 1716, 0, 240, 244, 247, 262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 9:1440x240@60Hz */
+    {MODEPREFIX, 54000, 2880, 2956, 3204, 3432, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 10:2880x480i@60Hz */
+    {MODEPREFIX, 54000, 2880, 2956, 3204, 3432, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 11:2880x480i@60Hz */
+    {MODEPREFIX, 54000, 2880, 2956, 3204, 3432, 0, 240, 244, 247, 262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 12:2880x240@60Hz */
+    {MODEPREFIX, 54000, 2880, 2956, 3204, 3432, 0, 240, 244, 247, 262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 13:2880x240@60Hz */
+    {MODEPREFIX, 54000, 1440, 1472, 1596, 1716, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 14:1440x480@60Hz */
+    {MODEPREFIX, 54000, 1440, 1472, 1596, 1716, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 15:1440x480@60Hz */
+    {MODEPREFIX, 148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* VIC 16:1920x1080@60Hz */
+    {MODEPREFIX, 27000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 17:720x576@50Hz */
+    {MODEPREFIX, 27000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 18:720x576@50Hz */
+    {MODEPREFIX, 74250, 1280, 1720, 1760, 1980, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* VIC 19: 1280x720@50Hz */
+    {MODEPREFIX, 74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},   /* VIC 20:1920x1080i@50Hz */
+    {MODEPREFIX, 27000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 21:1440x576i@50Hz */
+    {MODEPREFIX, 27000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 22:1440x576i@50Hz */
+    {MODEPREFIX, 27000, 1440, 1464, 1590, 1728, 0, 288, 290, 293, 312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 23:1440x288@50Hz */
+    {MODEPREFIX, 27000, 1440, 1464, 1590, 1728, 0, 288, 290, 293, 312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 24:1440x288@50Hz */
+    {MODEPREFIX, 54000, 2880, 2928, 3180, 3456, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 25:2880x576i@50Hz */
+    {MODEPREFIX, 54000, 2880, 2928, 3180, 3456, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 26:2880x576i@50Hz */
+    {MODEPREFIX, 54000, 2880, 2928, 3180, 3456, 0, 288, 290, 293, 312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 27:2880x288@50Hz */
+    {MODEPREFIX, 54000, 2880, 2928, 3180, 3456, 0, 288, 290, 293, 312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 28:2880x288@50Hz */
+    {MODEPREFIX, 54000, 1440, 1464, 1592, 1728, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 29:1440x576@50Hz */
+    {MODEPREFIX, 54000, 1440, 1464, 1592, 1728, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 30:1440x576@50Hz */
+    {MODEPREFIX, 148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* VIC 31:1920x1080@50Hz */
+    {MODEPREFIX, 74250, 1920, 2558, 2602, 2750, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX}, /* VIC 32:1920x1080@24Hz */
+    {MODEPREFIX, 74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX}, /* VIC 33:1920x1080@25Hz */
+    {MODEPREFIX, 74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX}, /* VIC 34:1920x1080@30Hz */
+    {MODEPREFIX, 108000, 2880, 2944, 3192, 3432, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},    /* VIC 35:2880x480@60Hz */
+    {MODEPREFIX, 108000, 2880, 2944, 3192, 3432, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},    /* VIC 36:2880x480@60Hz */
+    {MODEPREFIX, 108000, 2880, 2928, 3184, 3456, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},    /* VIC 37:2880x576@50Hz */
+    {MODEPREFIX, 108000, 2880, 2928, 3184, 3456, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},    /* VIC 38:2880x576@50Hz */
+    {MODEPREFIX, 72000, 1920, 1952, 2120, 2304, 0, 1080, 1126, 1136, 1250, 0, V_PHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},   /* VIC 39:1920x1080i@50Hz */
+    {MODEPREFIX, 148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},  /* VIC 40:1920x1080i@100Hz */
+    {MODEPREFIX, 148500, 1280, 1720, 1760, 1980, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},    /* VIC 41:1280x720@100Hz */
+    {MODEPREFIX, 54000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 42:720x576@100Hz */
+    {MODEPREFIX, 54000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 43:720x576@100Hz */
+    {MODEPREFIX, 54000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 44:1440x576i@100Hz */
+    {MODEPREFIX, 54000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},     /* VIC 45:1440x576i@100Hz */
+    {MODEPREFIX, 148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX},  /* VIC 46:1920x1080i@120Hz */
+    {MODEPREFIX, 148500, 1280, 1390, 1430, 1650, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},    /* VIC 47:1280x720@120Hz */
+    {MODEPREFIX, 54000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 48:720x480@120Hz */
+    {MODEPREFIX, 54000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX}, /* VIC 49:720x480@120Hz */
+    {MODEPREFIX, 54000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 50:1440x480i@120Hz */
+    {MODEPREFIX, 54000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},       /* VIC 51:1440x480i@120Hz */
+    {MODEPREFIX, 108000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},        /* VIC 52:720x576@200Hz */
+    {MODEPREFIX, 108000, 720, 732, 796, 864, 0, 576, 581, 586, 625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},        /* VIC 53:720x576@200Hz */
+    {MODEPREFIX, 108000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},      /* VIC 54:1440x576i@200Hz */
+    {MODEPREFIX, 108000, 1440, 1464, 1590, 1728, 0, 576, 580, 586, 625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},      /* VIC 55:1440x576i@200Hz */
+    {MODEPREFIX, 108000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},        /* VIC 56:720x480@240Hz */
+    {MODEPREFIX, 108000, 720, 736, 798, 858, 0, 480, 489, 495, 525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX},        /* VIC 57:720x480@240Hz */
+    {MODEPREFIX, 108000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},      /* VIC 58:1440x480i@240 */
+    {MODEPREFIX, 108000, 1440, 1478, 1602, 1716, 0, 480, 488, 494, 525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX},      /* VIC 59:1440x480i@240 */
+    {MODEPREFIX, 59400, 1280, 3040, 3080, 3300, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* VIC 60: 1280x720@24Hz */
+    {MODEPREFIX, 74250, 1280, 3700, 3740, 3960, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* VIC 61: 1280x720@25Hz */
+    {MODEPREFIX, 74250, 1280, 3040, 3080, 3300, 0, 720, 725, 730, 750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},     /* VIC 62: 1280x720@30Hz */
+    {MODEPREFIX, 297000, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* VIC 63: 1920x1080@120Hz */
+    {MODEPREFIX, 297000, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX},        /* VIC 64:1920x1080@100Hz */
 };
 
 /* chose mode line by cea short video descriptor*/
-static void handle_cea_svd(struct cea_video_block *video, void *data)
+static void
+handle_cea_svd(struct cea_video_block *video, void *data)
 {
     DisplayModePtr Mode;
     DisplayModePtr *Modes = (DisplayModePtr *) data;
     int vid;
 
-    vid = video ->video_code & 0x7f;
+    vid = video->video_code & 0x7f;
     if (vid < CEA_VIDEO_MODES_NUM) {
-	Mode = xf86DuplicateMode(CEAVideoModes + vid);
-	*Modes = xf86ModesAdd(*Modes, Mode);
+        Mode = xf86DuplicateMode(CEAVideoModes + vid);
+        *Modes = xf86ModesAdd(*Modes, Mode);
     }
 }
 
@@ -989,9 +976,7 @@ DDCModesFromCEAExtension(int scrnIndex, xf86MonPtr MonPtr)
 {
     DisplayModePtr Modes = NULL;
 
-    xf86ForEachVideoBlock(MonPtr,
-                          handle_cea_svd,
-                          &Modes);
+    xf86ForEachVideoBlock(MonPtr, handle_cea_svd, &Modes);
 
     return Modes;
 }
@@ -999,34 +984,32 @@ DDCModesFromCEAExtension(int scrnIndex, xf86MonPtr MonPtr)
 struct det_modes_parameter {
     xf86MonPtr DDC;
     ddc_quirk_t quirks;
-    DisplayModePtr  Modes;
+    DisplayModePtr Modes;
     Bool rb;
     Bool preferred;
     int timing_level;
 };
 
-static void handle_detailed_modes(struct detailed_monitor_section *det_mon,
-	                          void *data)
+static void
+handle_detailed_modes(struct detailed_monitor_section *det_mon, void *data)
 {
-    DisplayModePtr  Mode;
-    struct det_modes_parameter *p = (struct det_modes_parameter *)data;
+    DisplayModePtr Mode;
+    struct det_modes_parameter *p = (struct det_modes_parameter *) data;
 
-    xf86DetTimingApplyQuirks(det_mon,p->quirks,
-                             p->DDC->features.hsize,
-                             p->DDC->features.vsize);
+    xf86DetTimingApplyQuirks(det_mon, p->quirks,
+                             p->DDC->features.hsize, p->DDC->features.vsize);
 
     switch (det_mon->type) {
     case DT:
         Mode = DDCModeFromDetailedTiming(p->DDC->scrnIndex,
                                          &det_mon->section.d_timings,
-                                         p->preferred,
-                                         p->quirks);
+                                         p->preferred, p->quirks);
         p->preferred = FALSE;
         p->Modes = xf86ModesAdd(p->Modes, Mode);
         break;
     case DS_STD_TIMINGS:
         Mode = DDCModesFromStandardTiming(det_mon->section.std_t,
-                                          p->quirks, p->timing_level,p->rb);
+                                          p->quirks, p->timing_level, p->rb);
         p->Modes = xf86ModesAdd(p->Modes, Mode);
         break;
     case DS_CVT:
@@ -1034,9 +1017,9 @@ static void handle_detailed_modes(struct detailed_monitor_section *det_mon,
         p->Modes = xf86ModesAdd(p->Modes, Mode);
         break;
     case DS_EST_III:
-	Mode = DDCModesFromEstIII(det_mon->section.est_iii);
-	p->Modes = xf86ModesAdd(p->Modes, Mode);
-	break;
+        Mode = DDCModesFromEstIII(det_mon->section.est_iii);
+        p->Modes = xf86ModesAdd(p->Modes, Mode);
+        break;
     default:
         break;
     }
@@ -1045,24 +1028,24 @@ static void handle_detailed_modes(struct detailed_monitor_section *det_mon,
 DisplayModePtr
 xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
 {
-    DisplayModePtr  Modes = NULL, Mode;
-    ddc_quirk_t	    quirks;
-    Bool	    preferred, rb;
-    int		    timing_level;
+    DisplayModePtr Modes = NULL, Mode;
+    ddc_quirk_t quirks;
+    Bool preferred, rb;
+    int timing_level;
     struct det_modes_parameter p;
 
-    xf86DrvMsg (scrnIndex, X_INFO, "EDID vendor \"%s\", prod id %d\n",
-		DDC->vendor.name, DDC->vendor.prod_id);
+    xf86DrvMsg(scrnIndex, X_INFO, "EDID vendor \"%s\", prod id %d\n",
+               DDC->vendor.name, DDC->vendor.prod_id);
 
     quirks = xf86DDCDetectQuirks(scrnIndex, DDC, TRUE);
 
     preferred = PREFERRED_TIMING_MODE(DDC->features.msc);
     if (DDC->ver.revision >= 4)
-	preferred = TRUE;
+        preferred = TRUE;
     if (quirks & DDC_QUIRK_FIRST_DETAILED_PREFERRED)
-	preferred = TRUE;
+        preferred = TRUE;
     if (quirks & (DDC_QUIRK_PREFER_LARGE_60 | DDC_QUIRK_PREFER_LARGE_75))
-	preferred = FALSE;
+        preferred = FALSE;
 
     rb = xf86MonitorSupportsReducedBlanking(DDC);
 
@@ -1086,14 +1069,14 @@ xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
     Modes = xf86ModesAdd(Modes, Mode);
 
     /* Add cea-extension mode timings */
-    Mode = DDCModesFromCEAExtension(scrnIndex,DDC);
+    Mode = DDCModesFromCEAExtension(scrnIndex, DDC);
     Modes = xf86ModesAdd(Modes, Mode);
 
     if (quirks & DDC_QUIRK_PREFER_LARGE_60)
-	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 60);
+        xf86DDCSetPreferredRefresh(scrnIndex, Modes, 60);
 
     if (quirks & DDC_QUIRK_PREFER_LARGE_75)
-	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 75);
+        xf86DDCSetPreferredRefresh(scrnIndex, Modes, 75);
 
     Modes = xf86PruneDuplicateModes(Modes);
 
@@ -1108,41 +1091,43 @@ struct det_mon_parameter {
     Bool have_maxpixclock;
 };
 
-static void handle_detailed_monset(struct detailed_monitor_section *det_mon,
-                                   void *data)
+static void
+handle_detailed_monset(struct detailed_monitor_section *det_mon, void *data)
 {
     int clock;
-    struct det_mon_parameter *p = (struct det_mon_parameter *)data;
-    int scrnIndex = ((xf86MonPtr)(p->Monitor->DDC))->scrnIndex;
+    struct det_mon_parameter *p = (struct det_mon_parameter *) data;
+    int scrnIndex = ((xf86MonPtr) (p->Monitor->DDC))->scrnIndex;
 
     switch (det_mon->type) {
     case DS_RANGES:
         if (!p->have_hsync) {
             if (!p->Monitor->nHsync)
                 xf86DrvMsg(scrnIndex, X_INFO,
-                    "Using EDID range info for horizontal sync\n");
-                p->Monitor->hsync[p->Monitor->nHsync].lo =
-                    det_mon->section.ranges.min_h;
-                p->Monitor->hsync[p->Monitor->nHsync].hi =
-                    det_mon->section.ranges.max_h;
-                p->Monitor->nHsync++;
-        } else {
+                           "Using EDID range info for horizontal sync\n");
+            p->Monitor->hsync[p->Monitor->nHsync].lo =
+                det_mon->section.ranges.min_h;
+            p->Monitor->hsync[p->Monitor->nHsync].hi =
+                det_mon->section.ranges.max_h;
+            p->Monitor->nHsync++;
+        }
+        else {
             xf86DrvMsg(scrnIndex, X_INFO,
-                "Using hsync ranges from config file\n");
+                       "Using hsync ranges from config file\n");
         }
 
         if (!p->have_vrefresh) {
             if (!p->Monitor->nVrefresh)
                 xf86DrvMsg(scrnIndex, X_INFO,
-                    "Using EDID range info for vertical refresh\n");
+                           "Using EDID range info for vertical refresh\n");
             p->Monitor->vrefresh[p->Monitor->nVrefresh].lo =
                 det_mon->section.ranges.min_v;
             p->Monitor->vrefresh[p->Monitor->nVrefresh].hi =
                 det_mon->section.ranges.max_v;
             p->Monitor->nVrefresh++;
-        } else {
+        }
+        else {
             xf86DrvMsg(scrnIndex, X_INFO,
-                "Using vrefresh ranges from config file\n");
+                       "Using vrefresh ranges from config file\n");
         }
 
         clock = det_mon->section.ranges.max_clock * 1000;
@@ -1172,8 +1157,8 @@ xf86EdidMonitorSet(int scrnIndex, MonPtr Monitor, xf86MonPtr DDC)
     Monitor->DDC = DDC;
 
     if (Monitor->widthmm <= 0 || Monitor->heightmm <= 0) {
-	Monitor->widthmm = 10 * DDC->features.hsize;
-	Monitor->heightmm = 10 * DDC->features.vsize;
+        Monitor->widthmm = 10 * DDC->features.hsize;
+        Monitor->heightmm = 10 * DDC->features.vsize;
     }
 
     Monitor->reducedblanking = xf86MonitorSupportsReducedBlanking(DDC);
@@ -1213,7 +1198,8 @@ xf86EdidMonitorSet(int scrnIndex, MonPtr Monitor, xf86MonPtr DDC)
             Monitor->Last->next = Modes;
             Modes->prev = Monitor->Last;
             Monitor->Last = Mode;
-        } else {
+        }
+        else {
             Monitor->Modes = Modes;
             Monitor->Last = Mode;
         }
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;
diff --git a/xorg-server/hw/xfree86/modes/xf86Modes.h b/xorg-server/hw/xfree86/modes/xf86Modes.h
index 89ec0d81d..aec7688c4 100644
--- a/xorg-server/hw/xfree86/modes/xf86Modes.h
+++ b/xorg-server/hw/xfree86/modes/xf86Modes.h
@@ -40,74 +40,78 @@
 #include "xf86Rename.h"
 #endif
 
-extern _X_EXPORT double xf86ModeHSync(const DisplayModeRec *mode);
-extern _X_EXPORT double xf86ModeVRefresh(const DisplayModeRec *mode);
+extern _X_EXPORT double xf86ModeHSync(const DisplayModeRec * mode);
+extern _X_EXPORT double xf86ModeVRefresh(const DisplayModeRec * mode);
 extern _X_EXPORT unsigned int xf86ModeBandwidth(DisplayModePtr mode, int depth);
 
 extern _X_EXPORT int
-xf86ModeWidth (const DisplayModeRec *mode, Rotation rotation);
-    
+ xf86ModeWidth(const DisplayModeRec * mode, Rotation rotation);
+
 extern _X_EXPORT int
-xf86ModeHeight (const DisplayModeRec *mode, Rotation rotation);
+ xf86ModeHeight(const DisplayModeRec * mode, Rotation rotation);
 
-extern _X_EXPORT DisplayModePtr xf86DuplicateMode(const DisplayModeRec *pMode);
+extern _X_EXPORT DisplayModePtr xf86DuplicateMode(const DisplayModeRec * pMode);
 extern _X_EXPORT DisplayModePtr xf86DuplicateModes(ScrnInfoPtr pScrn,
-				       DisplayModePtr modeList);
+                                                   DisplayModePtr modeList);
 extern _X_EXPORT void xf86SetModeDefaultName(DisplayModePtr mode);
 extern _X_EXPORT void xf86SetModeCrtc(DisplayModePtr p, int adjustFlags);
-extern _X_EXPORT Bool xf86ModesEqual(const DisplayModeRec *pMode1,
-		    const DisplayModeRec *pMode2);
-extern _X_EXPORT void xf86PrintModeline(int scrnIndex,DisplayModePtr mode);
-extern _X_EXPORT DisplayModePtr xf86ModesAdd(DisplayModePtr modes, DisplayModePtr new);
+extern _X_EXPORT Bool xf86ModesEqual(const DisplayModeRec * pMode1,
+                                     const DisplayModeRec * pMode2);
+extern _X_EXPORT void xf86PrintModeline(int scrnIndex, DisplayModePtr mode);
+extern _X_EXPORT DisplayModePtr xf86ModesAdd(DisplayModePtr modes,
+                                             DisplayModePtr new);
 
 extern _X_EXPORT DisplayModePtr xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC);
-extern _X_EXPORT DisplayModePtr xf86CVTMode(int HDisplay, int VDisplay, float VRefresh,
-			   Bool Reduced, Bool Interlaced);
-extern _X_EXPORT DisplayModePtr xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins);
+extern _X_EXPORT DisplayModePtr xf86CVTMode(int HDisplay, int VDisplay,
+                                            float VRefresh, Bool Reduced,
+                                            Bool Interlaced);
+extern _X_EXPORT DisplayModePtr xf86GTFMode(int h_pixels, int v_lines,
+                                            float freq, int interlaced,
+                                            int margins);
 
 extern _X_EXPORT Bool
-xf86ModeIsReduced(const DisplayModeRec *mode);
+ xf86ModeIsReduced(const DisplayModeRec * mode);
 
 extern _X_EXPORT void
-xf86ValidateModesFlags(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-		       int flags);
+ xf86ValidateModesFlags(ScrnInfoPtr pScrn, DisplayModePtr modeList, int flags);
 
 extern _X_EXPORT void
+
 xf86ValidateModesClocks(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			int *min, int *max, int n_ranges);
+                        int *min, int *max, int n_ranges);
 
 extern _X_EXPORT void
+
 xf86ValidateModesSize(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-		      int maxX, int maxY, int maxPitch);
+                      int maxX, int maxY, int maxPitch);
 
 extern _X_EXPORT void
-xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-		      MonPtr mon);
+ xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList, MonPtr mon);
 
 extern _X_EXPORT void
+
 xf86ValidateModesBandwidth(ScrnInfoPtr pScrn, DisplayModePtr modeList,
-			   unsigned int bandwidth, int depth);
+                           unsigned int bandwidth, int depth);
 
 extern _X_EXPORT void
-xf86ValidateModesReducedBlanking(ScrnInfoPtr pScrn, DisplayModePtr modeList);
+ xf86ValidateModesReducedBlanking(ScrnInfoPtr pScrn, DisplayModePtr modeList);
 
 extern _X_EXPORT void
-xf86PruneInvalidModes(ScrnInfoPtr pScrn, DisplayModePtr *modeList,
-		      Bool verbose);
 
-extern _X_EXPORT DisplayModePtr
-xf86PruneDuplicateModes(DisplayModePtr modes);
+xf86PruneInvalidModes(ScrnInfoPtr pScrn, DisplayModePtr * modeList,
+                      Bool verbose);
+
+extern _X_EXPORT DisplayModePtr xf86PruneDuplicateModes(DisplayModePtr modes);
 
 extern _X_EXPORT void
-xf86ValidateModesUserConfig(ScrnInfoPtr pScrn, DisplayModePtr modeList);
+ xf86ValidateModesUserConfig(ScrnInfoPtr pScrn, DisplayModePtr modeList);
 
 extern _X_EXPORT DisplayModePtr
-xf86GetMonitorModes (ScrnInfoPtr pScrn, XF86ConfMonitorPtr conf_monitor);
+xf86GetMonitorModes(ScrnInfoPtr pScrn, XF86ConfMonitorPtr conf_monitor);
 
-extern _X_EXPORT DisplayModePtr
-xf86GetDefaultModes (void);
+extern _X_EXPORT DisplayModePtr xf86GetDefaultModes(void);
 
 extern _X_EXPORT void
-xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC);
+ xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC);
 
-#endif /* _XF86MODES_H_ */
+#endif                          /* _XF86MODES_H_ */
diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index d5031a2f1..a773c34c6 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -43,16 +43,16 @@
 #include "xf86RandR12.h"
 
 typedef struct _xf86RandR12Info {
-    int				    virtualX;
-    int				    virtualY;
-    int				    mmWidth;
-    int				    mmHeight;
-    int				    maxX;
-    int				    maxY;
-    int				    pointerX;
-    int				    pointerY;
-    Rotation			    rotation; /* current mode */
-    Rotation                        supported_rotations; /* driver supported */
+    int virtualX;
+    int virtualY;
+    int mmWidth;
+    int mmHeight;
+    int maxX;
+    int maxY;
+    int pointerX;
+    int pointerY;
+    Rotation rotation;          /* current mode */
+    Rotation supported_rotations;       /* driver supported */
 
     /* Used to wrap EnterVT so we can re-probe the outputs when a laptop unsuspends
      * (actually, any time that we switch back into our VT).
@@ -63,106 +63,117 @@ typedef struct _xf86RandR12Info {
 } XF86RandRInfoRec, *XF86RandRInfoPtr;
 
 #ifdef RANDR_12_INTERFACE
-static Bool xf86RandR12Init12 (ScreenPtr pScreen);
-static Bool xf86RandR12CreateScreenResources12 (ScreenPtr pScreen);
+static Bool xf86RandR12Init12(ScreenPtr pScreen);
+static Bool xf86RandR12CreateScreenResources12(ScreenPtr pScreen);
 #endif
 
 static int xf86RandR12Generation;
 
 static DevPrivateKeyRec xf86RandR12KeyRec;
 static DevPrivateKey xf86RandR12Key;
+
 #define XF86RANDRINFO(p) ((XF86RandRInfoPtr) \
     dixLookupPrivate(&(p)->devPrivates, xf86RandR12Key))
 
-
 static int
-xf86RandR12ModeRefresh (DisplayModePtr mode)
+xf86RandR12ModeRefresh(DisplayModePtr mode)
 {
     if (mode->VRefresh)
-	return (int) (mode->VRefresh + 0.5);
+        return (int) (mode->VRefresh + 0.5);
     else
-	return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
+        return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
 }
 
 /* Adapt panning area; return TRUE if panning area was valid without adaption */
 static int
-xf86RandR13VerifyPanningArea (xf86CrtcPtr crtc, int screenWidth, int screenHeight)
+xf86RandR13VerifyPanningArea(xf86CrtcPtr crtc, int screenWidth,
+                             int screenHeight)
 {
     int ret = TRUE;
 
     if (crtc->version < 2)
-	return FALSE;
+        return FALSE;
 
     if (crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1) {
-	/* Panning in X is disabled */
-	if (crtc->panningTotalArea.x1 || crtc->panningTotalArea.x2)
-	    /* Illegal configuration -> fail/disable */
-	    ret = FALSE;
-	crtc->panningTotalArea.x1    = crtc->panningTotalArea.x2    = 0;
-	crtc->panningTrackingArea.x1 = crtc->panningTrackingArea.x2 = 0;
-	crtc->panningBorder[0]       = crtc->panningBorder[2]       = 0;
-    } else {
-	/* Panning in X is enabled */
-	if (crtc->panningTotalArea.x1 < 0) {
-	    /* Panning region outside screen -> move inside */
-	    crtc->panningTotalArea.x2 -= crtc->panningTotalArea.x1;
-	    crtc->panningTotalArea.x1 = 0;
-	    ret = FALSE;
-	}
-	if (crtc->panningTotalArea.x2 < crtc->panningTotalArea.x1 + crtc->mode.HDisplay) {
-	    /* Panning region smaller than displayed area -> crop to displayed area */
-	    crtc->panningTotalArea.x2 = crtc->panningTotalArea.x1 + crtc->mode.HDisplay;
-	    ret = FALSE;
-	}
-	if (crtc->panningTotalArea.x2 > screenWidth) {
-	    /* Panning region larger than screen -> move inside, then crop to screen */
-	    crtc->panningTotalArea.x1 -= crtc->panningTotalArea.x2 - screenWidth;
-	    crtc->panningTotalArea.x2 = screenWidth;
-	    ret = FALSE;
-	    if (crtc->panningTotalArea.x1 < 0)
-		crtc->panningTotalArea.x1 = 0;
-	}
-	if (crtc->panningBorder[0] + crtc->panningBorder[2] > crtc->mode.HDisplay) {
-	    /* Borders too large -> set to 0 */
-	    crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
-	    ret = FALSE;
-	}
+        /* Panning in X is disabled */
+        if (crtc->panningTotalArea.x1 || crtc->panningTotalArea.x2)
+            /* Illegal configuration -> fail/disable */
+            ret = FALSE;
+        crtc->panningTotalArea.x1 = crtc->panningTotalArea.x2 = 0;
+        crtc->panningTrackingArea.x1 = crtc->panningTrackingArea.x2 = 0;
+        crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
+    }
+    else {
+        /* Panning in X is enabled */
+        if (crtc->panningTotalArea.x1 < 0) {
+            /* Panning region outside screen -> move inside */
+            crtc->panningTotalArea.x2 -= crtc->panningTotalArea.x1;
+            crtc->panningTotalArea.x1 = 0;
+            ret = FALSE;
+        }
+        if (crtc->panningTotalArea.x2 <
+            crtc->panningTotalArea.x1 + crtc->mode.HDisplay) {
+            /* Panning region smaller than displayed area -> crop to displayed area */
+            crtc->panningTotalArea.x2 =
+                crtc->panningTotalArea.x1 + crtc->mode.HDisplay;
+            ret = FALSE;
+        }
+        if (crtc->panningTotalArea.x2 > screenWidth) {
+            /* Panning region larger than screen -> move inside, then crop to screen */
+            crtc->panningTotalArea.x1 -=
+                crtc->panningTotalArea.x2 - screenWidth;
+            crtc->panningTotalArea.x2 = screenWidth;
+            ret = FALSE;
+            if (crtc->panningTotalArea.x1 < 0)
+                crtc->panningTotalArea.x1 = 0;
+        }
+        if (crtc->panningBorder[0] + crtc->panningBorder[2] >
+            crtc->mode.HDisplay) {
+            /* Borders too large -> set to 0 */
+            crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
+            ret = FALSE;
+        }
     }
 
     if (crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1) {
-	/* Panning in Y is disabled */
-	if (crtc->panningTotalArea.y1 || crtc->panningTotalArea.y2)
-	    /* Illegal configuration -> fail/disable */
-	    ret = FALSE;
-	crtc->panningTotalArea.y1    = crtc->panningTotalArea.y2    = 0;
-	crtc->panningTrackingArea.y1 = crtc->panningTrackingArea.y2 = 0;
-	crtc->panningBorder[1]       = crtc->panningBorder[3]       = 0;
-    } else {
-	/* Panning in Y is enabled */
-	if (crtc->panningTotalArea.y1 < 0) {
-	    /* Panning region outside screen -> move inside */
-	    crtc->panningTotalArea.y2 -= crtc->panningTotalArea.y1;
-	    crtc->panningTotalArea.y1 = 0;
-	    ret = FALSE;
-	}
-	if (crtc->panningTotalArea.y2 < crtc->panningTotalArea.y1 + crtc->mode.VDisplay) {
-	    /* Panning region smaller than displayed area -> crop to displayed area */
-	    crtc->panningTotalArea.y2 = crtc->panningTotalArea.y1 + crtc->mode.VDisplay;
-	    ret = FALSE;
-	}
-	if (crtc->panningTotalArea.y2 > screenHeight) {
-	    /* Panning region larger than screen -> move inside, then crop to screen */
-	    crtc->panningTotalArea.y1 -= crtc->panningTotalArea.y2 - screenHeight;
-	    crtc->panningTotalArea.y2 = screenHeight;
-	    ret = FALSE;
-	    if (crtc->panningTotalArea.y1 < 0)
-		crtc->panningTotalArea.y1 = 0;
-	}
-	if (crtc->panningBorder[1] + crtc->panningBorder[3] > crtc->mode.VDisplay) {
-	    /* Borders too large -> set to 0 */
-	    crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
-	    ret = FALSE;
-	}
+        /* Panning in Y is disabled */
+        if (crtc->panningTotalArea.y1 || crtc->panningTotalArea.y2)
+            /* Illegal configuration -> fail/disable */
+            ret = FALSE;
+        crtc->panningTotalArea.y1 = crtc->panningTotalArea.y2 = 0;
+        crtc->panningTrackingArea.y1 = crtc->panningTrackingArea.y2 = 0;
+        crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
+    }
+    else {
+        /* Panning in Y is enabled */
+        if (crtc->panningTotalArea.y1 < 0) {
+            /* Panning region outside screen -> move inside */
+            crtc->panningTotalArea.y2 -= crtc->panningTotalArea.y1;
+            crtc->panningTotalArea.y1 = 0;
+            ret = FALSE;
+        }
+        if (crtc->panningTotalArea.y2 <
+            crtc->panningTotalArea.y1 + crtc->mode.VDisplay) {
+            /* Panning region smaller than displayed area -> crop to displayed area */
+            crtc->panningTotalArea.y2 =
+                crtc->panningTotalArea.y1 + crtc->mode.VDisplay;
+            ret = FALSE;
+        }
+        if (crtc->panningTotalArea.y2 > screenHeight) {
+            /* Panning region larger than screen -> move inside, then crop to screen */
+            crtc->panningTotalArea.y1 -=
+                crtc->panningTotalArea.y2 - screenHeight;
+            crtc->panningTotalArea.y2 = screenHeight;
+            ret = FALSE;
+            if (crtc->panningTotalArea.y1 < 0)
+                crtc->panningTotalArea.y1 = 0;
+        }
+        if (crtc->panningBorder[1] + crtc->panningBorder[3] >
+            crtc->mode.VDisplay) {
+            /* Borders too large -> set to 0 */
+            crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
+            ret = FALSE;
+        }
     }
 
     return ret;
@@ -179,232 +190,232 @@ xf86RandR13VerifyPanningArea (xf86CrtcPtr crtc, int screenWidth, int screenHeigh
  */
 
 static void
-xf86ComputeCrtcPan (Bool transform_in_use,
-		    struct pixman_f_transform *m,
-		    double screen_x, double screen_y,
-		    double crtc_x, double crtc_y,
-		    int old_pan_x, int old_pan_y,
-		    int *new_pan_x, int *new_pan_y)
+xf86ComputeCrtcPan(Bool transform_in_use,
+                   struct pixman_f_transform *m,
+                   double screen_x, double screen_y,
+                   double crtc_x, double crtc_y,
+                   int old_pan_x, int old_pan_y, int *new_pan_x, int *new_pan_y)
 {
     if (transform_in_use) {
-	/*
-	 * Given the current transform, M, the current position
-	 * on the Screen, S, and the desired position on the CRTC,
-	 * C, compute a translation, T, such that:
-	 *
-	 * M T S = C
-	 *
-	 * where T is of the form
-	 *
-	 * | 1 0 dx |
-	 * | 0 1 dy |
-	 * | 0 0 1  |
-	 *
-	 * M T S =
-	 *   | M00 Sx + M01 Sy + M00 dx + M01 dy + M02 |   | Cx F |
-	 *   | M10 Sx + M11 Sy + M10 dx + M11 dy + M12 | = | Cy F |
-	 *   | M20 Sx + M21 Sy + M20 dx + M21 dy + M22 |   |  F   |
-	 *
-	 * R = M S
-	 *
-	 *   Cx F = M00 dx + M01 dy + R0
-	 *   Cy F = M10 dx + M11 dy + R1
-	 *      F = M20 dx + M21 dy + R2
-	 *
-	 * Zero out dx, then dy
-	 *
-	 * F (Cx M10 - Cy M00) =
-	 *	    (M10 M01 - M00 M11) dy + M10 R0 - M00 R1
-	 * F (M10 - Cy M20) =
-	 *	    (M10 M21 - M20 M11) dy + M10 R2 - M20 R1
-	 *
-	 * F (Cx M11 - Cy M01) =
-	 *	    (M11 M00 - M01 M10) dx + M11 R0 - M01 R1
-	 * F (M11 - Cy M21) =
-	 *	    (M11 M20 - M21 M10) dx + M11 R2 - M21 R1
-	 *
-	 * Make some temporaries
-	 *
-	 * T = | Cx M10 - Cy M00 |
-	 *     | Cx M11 - Cy M01 |
-	 *
-	 * U = | M10 M01 - M00 M11 |
-	 *     | M11 M00 - M01 M10 |
-	 *
-	 * Q = | M10 R0 - M00 R1 |
-	 *     | M11 R0 - M01 R1 |
-	 *
-	 * P = | M10 - Cy M20 |
-	 *     | M11 - Cy M21 |
-	 *
-	 * W = | M10 M21 - M20 M11 |
-	 *     | M11 M20 - M21 M10 |
-	 *
-	 * V = | M10 R2 - M20 R1 |
-	 *	   | M11 R2 - M21 R1 |
-	 *
-	 * Rewrite:
-	 *
-	 * F T0 = U0 dy + Q0
-	 * F P0 = W0 dy + V0
-	 * F T1 = U1 dx + Q1
-	 * F P1 = W1 dx + V1
-	 *
-	 * Solve for F (two ways)
-	 *
-	 * F (W0 T0 - U0 P0)  = W0 Q0 - U0 V0
-	 *
-	 *     W0 Q0 - U0 V0
-	 * F = -------------
-	 *     W0 T0 - U0 P0
-	 *
-	 * F (W1 T1 - U1 P1) = W1 Q1 - U1 V1
-	 *
-	 *     W1 Q1 - U1 V1
-	 * F = -------------
-	 *     W1 T1 - U1 P1
-	 *
-	 * We'll use which ever solution works (denominator != 0)
-	 *
-	 * Finally, solve for dx and dy:
-	 *
-	 * dx = (F T1 - Q1) / U1
-	 * dx = (F P1 - V1) / W1
-	 *
-	 * dy = (F T0 - Q0) / U0
-	 * dy = (F P0 - V0) / W0
-	 */
-	double			    r[3];
-	double			    q[2], u[2], t[2], v[2], w[2], p[2];
-	double			    f;
-	struct pict_f_vector	    d;
-	int			    i;
-
-	/* Get the un-normalized crtc coordinates again */
-	for (i = 0; i < 3; i++)
-	    r[i] = m->m[i][0] * screen_x + m->m[i][1] * screen_y + m->m[i][2];
-
-	/* Combine values into temporaries */
-	for (i = 0; i < 2; i++) {
-	    q[i] = m->m[1][i] * r[0] - m->m[0][i] * r[1];
-	    u[i] = m->m[1][i] * m->m[0][1-i] - m->m[0][i] * m->m[1][1-i];
-	    t[i] = m->m[1][i] * crtc_x - m->m[0][i] * crtc_y;
-
-	    v[i] = m->m[1][i] * r[2] - m->m[2][i] * r[1];
-	    w[i] = m->m[1][i] * m->m[2][1-i] - m->m[2][i] * m->m[1][1-i];
-	    p[i] = m->m[1][i] - m->m[2][i] * crtc_y;
-	}
-
-	/* Find a way to compute f */
-	f = 0;
-	for (i = 0; i < 2; i++) {
-	    double a = w[i] * q[i] - u[i] * v[i];
-	    double b = w[i] * t[i] - u[i] * p[i];
-	    if (b != 0) {
-		f = a/b;
-		break;
-	    }
-	}
-
-	/* Solve for the resulting transform vector */
-	for (i = 0; i < 2; i++) {
-	    if (u[i])
-		d.v[1-i] = (t[i] * f - q[i]) / u[i];
-	    else if (w[1])
-		d.v[1-i] = (p[i] * f - v[i]) / w[i];
-	    else
-		d.v[1-i] = 0;
-	}
-	*new_pan_x = old_pan_x - floor (d.v[0] + 0.5);
-	*new_pan_y = old_pan_y - floor (d.v[1] + 0.5);
-    } else {
-	*new_pan_x = screen_x - crtc_x;
-	*new_pan_y = screen_y - crtc_y;
+        /*
+         * Given the current transform, M, the current position
+         * on the Screen, S, and the desired position on the CRTC,
+         * C, compute a translation, T, such that:
+         *
+         * M T S = C
+         *
+         * where T is of the form
+         *
+         * | 1 0 dx |
+         * | 0 1 dy |
+         * | 0 0 1  |
+         *
+         * M T S =
+         *   | M00 Sx + M01 Sy + M00 dx + M01 dy + M02 |   | Cx F |
+         *   | M10 Sx + M11 Sy + M10 dx + M11 dy + M12 | = | Cy F |
+         *   | M20 Sx + M21 Sy + M20 dx + M21 dy + M22 |   |  F   |
+         *
+         * R = M S
+         *
+         *   Cx F = M00 dx + M01 dy + R0
+         *   Cy F = M10 dx + M11 dy + R1
+         *      F = M20 dx + M21 dy + R2
+         *
+         * Zero out dx, then dy
+         *
+         * F (Cx M10 - Cy M00) =
+         *          (M10 M01 - M00 M11) dy + M10 R0 - M00 R1
+         * F (M10 - Cy M20) =
+         *          (M10 M21 - M20 M11) dy + M10 R2 - M20 R1
+         *
+         * F (Cx M11 - Cy M01) =
+         *          (M11 M00 - M01 M10) dx + M11 R0 - M01 R1
+         * F (M11 - Cy M21) =
+         *          (M11 M20 - M21 M10) dx + M11 R2 - M21 R1
+         *
+         * Make some temporaries
+         *
+         * T = | Cx M10 - Cy M00 |
+         *     | Cx M11 - Cy M01 |
+         *
+         * U = | M10 M01 - M00 M11 |
+         *     | M11 M00 - M01 M10 |
+         *
+         * Q = | M10 R0 - M00 R1 |
+         *     | M11 R0 - M01 R1 |
+         *
+         * P = | M10 - Cy M20 |
+         *     | M11 - Cy M21 |
+         *
+         * W = | M10 M21 - M20 M11 |
+         *     | M11 M20 - M21 M10 |
+         *
+         * V = | M10 R2 - M20 R1 |
+         *         | M11 R2 - M21 R1 |
+         *
+         * Rewrite:
+         *
+         * F T0 = U0 dy + Q0
+         * F P0 = W0 dy + V0
+         * F T1 = U1 dx + Q1
+         * F P1 = W1 dx + V1
+         *
+         * Solve for F (two ways)
+         *
+         * F (W0 T0 - U0 P0)  = W0 Q0 - U0 V0
+         *
+         *     W0 Q0 - U0 V0
+         * F = -------------
+         *     W0 T0 - U0 P0
+         *
+         * F (W1 T1 - U1 P1) = W1 Q1 - U1 V1
+         *
+         *     W1 Q1 - U1 V1
+         * F = -------------
+         *     W1 T1 - U1 P1
+         *
+         * We'll use which ever solution works (denominator != 0)
+         *
+         * Finally, solve for dx and dy:
+         *
+         * dx = (F T1 - Q1) / U1
+         * dx = (F P1 - V1) / W1
+         *
+         * dy = (F T0 - Q0) / U0
+         * dy = (F P0 - V0) / W0
+         */
+        double r[3];
+        double q[2], u[2], t[2], v[2], w[2], p[2];
+        double f;
+        struct pict_f_vector d;
+        int i;
+
+        /* Get the un-normalized crtc coordinates again */
+        for (i = 0; i < 3; i++)
+            r[i] = m->m[i][0] * screen_x + m->m[i][1] * screen_y + m->m[i][2];
+
+        /* Combine values into temporaries */
+        for (i = 0; i < 2; i++) {
+            q[i] = m->m[1][i] * r[0] - m->m[0][i] * r[1];
+            u[i] = m->m[1][i] * m->m[0][1 - i] - m->m[0][i] * m->m[1][1 - i];
+            t[i] = m->m[1][i] * crtc_x - m->m[0][i] * crtc_y;
+
+            v[i] = m->m[1][i] * r[2] - m->m[2][i] * r[1];
+            w[i] = m->m[1][i] * m->m[2][1 - i] - m->m[2][i] * m->m[1][1 - i];
+            p[i] = m->m[1][i] - m->m[2][i] * crtc_y;
+        }
+
+        /* Find a way to compute f */
+        f = 0;
+        for (i = 0; i < 2; i++) {
+            double a = w[i] * q[i] - u[i] * v[i];
+            double b = w[i] * t[i] - u[i] * p[i];
+
+            if (b != 0) {
+                f = a / b;
+                break;
+            }
+        }
+
+        /* Solve for the resulting transform vector */
+        for (i = 0; i < 2; i++) {
+            if (u[i])
+                d.v[1 - i] = (t[i] * f - q[i]) / u[i];
+            else if (w[1])
+                d.v[1 - i] = (p[i] * f - v[i]) / w[i];
+            else
+                d.v[1 - i] = 0;
+        }
+        *new_pan_x = old_pan_x - floor(d.v[0] + 0.5);
+        *new_pan_y = old_pan_y - floor(d.v[1] + 0.5);
+    }
+    else {
+        *new_pan_x = screen_x - crtc_x;
+        *new_pan_y = screen_y - crtc_y;
     }
 }
 
 static void
-xf86RandR13Pan (xf86CrtcPtr crtc, int x, int y)
+xf86RandR13Pan(xf86CrtcPtr crtc, int x, int y)
 {
     int newX, newY;
     int width, height;
     Bool panned = FALSE;
 
     if (crtc->version < 2)
-	return;
+        return;
 
-    if (! crtc->enabled						||
-	(crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1	&&
-	 crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1))
-	return;
+    if (!crtc->enabled ||
+        (crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1 &&
+         crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1))
+        return;
 
-    newX   = crtc->x;
-    newY   = crtc->y;
-    width  = crtc->mode.HDisplay;
+    newX = crtc->x;
+    newY = crtc->y;
+    width = crtc->mode.HDisplay;
     height = crtc->mode.VDisplay;
 
     if ((crtc->panningTrackingArea.x2 <= crtc->panningTrackingArea.x1 ||
-	 (x >= crtc->panningTrackingArea.x1 && x < crtc->panningTrackingArea.x2)) &&
-	(crtc->panningTrackingArea.y2 <= crtc->panningTrackingArea.y1 ||
-	 (y >= crtc->panningTrackingArea.y1 && y < crtc->panningTrackingArea.y2)))
-    {
-	struct pict_f_vector    c;
-
-	/*
-	 * Pre-clip the mouse position to the panning area so that we don't
-	 * push the crtc outside. This doesn't deal with changes to the
-	 * panning values, only mouse position changes.
-	 */
-	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1)
-	{
-	    if (x < crtc->panningTotalArea.x1)
-		x = crtc->panningTotalArea.x1;
-	    if (x >= crtc->panningTotalArea.x2)
-		x = crtc->panningTotalArea.x2 - 1;
-	}
-	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1)
-	{
-	    if (y < crtc->panningTotalArea.y1)
-		y = crtc->panningTotalArea.y1;
-	    if (y >= crtc->panningTotalArea.y2)
-		y = crtc->panningTotalArea.y2 - 1;
-	}
-
-	c.v[0] = x;
-	c.v[1] = y;
-	c.v[2] = 1.0;
-	if (crtc->transform_in_use) {
-	    pixman_f_transform_point(&crtc->f_framebuffer_to_crtc, &c);
-	} else {
-	    c.v[0] -= crtc->x;
-	    c.v[1] -= crtc->y;
-	}
-
-	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
-	    if (c.v[0] < crtc->panningBorder[0]) {
-		c.v[0] = crtc->panningBorder[0];
-		panned = TRUE;
-	    }
-	    if (c.v[0] >= width - crtc->panningBorder[2]) {
-		c.v[0] = width - crtc->panningBorder[2] - 1;
-		panned = TRUE;
-	    }
-	}
-	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
-	    if (c.v[1] < crtc->panningBorder[1]) {
-		c.v[1] = crtc->panningBorder[1];
-		panned = TRUE;
-	    }
-	    if (c.v[1] >= height - crtc->panningBorder[3]) {
-		c.v[1] = height - crtc->panningBorder[3] - 1;
-		panned = TRUE;
-	    }
-	}
-	if (panned)
-	    xf86ComputeCrtcPan (crtc->transform_in_use,
-				&crtc->f_framebuffer_to_crtc,
-				x, y, c.v[0], c.v[1],
-				newX, newY, &newX, &newY);
+         (x >= crtc->panningTrackingArea.x1 &&
+          x < crtc->panningTrackingArea.x2)) &&
+        (crtc->panningTrackingArea.y2 <= crtc->panningTrackingArea.y1 ||
+         (y >= crtc->panningTrackingArea.y1 &&
+          y < crtc->panningTrackingArea.y2))) {
+        struct pict_f_vector c;
+
+        /*
+         * Pre-clip the mouse position to the panning area so that we don't
+         * push the crtc outside. This doesn't deal with changes to the
+         * panning values, only mouse position changes.
+         */
+        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
+            if (x < crtc->panningTotalArea.x1)
+                x = crtc->panningTotalArea.x1;
+            if (x >= crtc->panningTotalArea.x2)
+                x = crtc->panningTotalArea.x2 - 1;
+        }
+        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+            if (y < crtc->panningTotalArea.y1)
+                y = crtc->panningTotalArea.y1;
+            if (y >= crtc->panningTotalArea.y2)
+                y = crtc->panningTotalArea.y2 - 1;
+        }
+
+        c.v[0] = x;
+        c.v[1] = y;
+        c.v[2] = 1.0;
+        if (crtc->transform_in_use) {
+            pixman_f_transform_point(&crtc->f_framebuffer_to_crtc, &c);
+        }
+        else {
+            c.v[0] -= crtc->x;
+            c.v[1] -= crtc->y;
+        }
+
+        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
+            if (c.v[0] < crtc->panningBorder[0]) {
+                c.v[0] = crtc->panningBorder[0];
+                panned = TRUE;
+            }
+            if (c.v[0] >= width - crtc->panningBorder[2]) {
+                c.v[0] = width - crtc->panningBorder[2] - 1;
+                panned = TRUE;
+            }
+        }
+        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+            if (c.v[1] < crtc->panningBorder[1]) {
+                c.v[1] = crtc->panningBorder[1];
+                panned = TRUE;
+            }
+            if (c.v[1] >= height - crtc->panningBorder[3]) {
+                c.v[1] = height - crtc->panningBorder[3] - 1;
+                panned = TRUE;
+            }
+        }
+        if (panned)
+            xf86ComputeCrtcPan(crtc->transform_in_use,
+                               &crtc->f_framebuffer_to_crtc,
+                               x, y, c.v[0], c.v[1], newX, newY, &newX, &newY);
     }
 
     /*
@@ -413,131 +424,119 @@ xf86RandR13Pan (xf86CrtcPtr crtc, int x, int y)
      * XXX This computation only works when we do not have a transform
      * in use.
      */
-    if (!crtc->transform_in_use)
-    {
-	/* Validate against [xy]1 after [xy]2, to be sure that results are > 0 for [xy]1 > 0 */
-	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
-	    if (newX > crtc->panningTotalArea.x2 - width)
-		newX =  crtc->panningTotalArea.x2 - width;
-	    if (newX <  crtc->panningTotalArea.x1)
-		newX =  crtc->panningTotalArea.x1;
-	}
-	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
-	    if (newY > crtc->panningTotalArea.y2 - height)
-		newY =  crtc->panningTotalArea.y2 - height;
-	    if (newY <  crtc->panningTotalArea.y1)
-		newY =  crtc->panningTotalArea.y1;
-	}
+    if (!crtc->transform_in_use) {
+        /* Validate against [xy]1 after [xy]2, to be sure that results are > 0 for [xy]1 > 0 */
+        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
+            if (newX > crtc->panningTotalArea.x2 - width)
+                newX = crtc->panningTotalArea.x2 - width;
+            if (newX < crtc->panningTotalArea.x1)
+                newX = crtc->panningTotalArea.x1;
+        }
+        if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+            if (newY > crtc->panningTotalArea.y2 - height)
+                newY = crtc->panningTotalArea.y2 - height;
+            if (newY < crtc->panningTotalArea.y1)
+                newY = crtc->panningTotalArea.y1;
+        }
     }
     if (newX != crtc->x || newY != crtc->y)
-	xf86CrtcSetOrigin (crtc, newX, newY);
+        xf86CrtcSetOrigin(crtc, newX, newY);
 }
 
 static Bool
-xf86RandR12GetInfo (ScreenPtr pScreen, Rotation *rotations)
+xf86RandR12GetInfo(ScreenPtr pScreen, Rotation * rotations)
 {
-    RRScreenSizePtr	    pSize;
-    ScrnInfoPtr		    scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	    randrp = XF86RANDRINFO(pScreen);
-    DisplayModePtr	    mode;
-    int			    refresh0 = 60;
-    int			    maxX = 0, maxY = 0;
+    RRScreenSizePtr pSize;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    DisplayModePtr mode;
+    int refresh0 = 60;
+    int maxX = 0, maxY = 0;
 
     *rotations = randrp->supported_rotations;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = scrp->virtualX;
-	randrp->virtualY = scrp->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = scrp->virtualX;
+        randrp->virtualY = scrp->virtualY;
     }
 
     /* Re-probe the outputs for new monitors or modes */
-    if (scrp->vtSema)
-    {
-	xf86ProbeOutputModes (scrp, 0, 0);
-	xf86SetScrnInfoModes (scrp);
+    if (scrp->vtSema) {
+        xf86ProbeOutputModes(scrp, 0, 0);
+        xf86SetScrnInfoModes(scrp);
     }
 
-    for (mode = scrp->modes; ; mode = mode->next)
-    {
-	int refresh = xf86RandR12ModeRefresh (mode);
-	if (randrp->maxX == 0 || randrp->maxY == 0)
-	{
-		if (maxX < mode->HDisplay)
-			maxX = mode->HDisplay;
-		if (maxY < mode->VDisplay)
-			maxY = mode->VDisplay;
-	}
-	if (mode == scrp->modes)
-	    refresh0 = refresh;
-	pSize = RRRegisterSize (pScreen,
-				mode->HDisplay, mode->VDisplay,
-				randrp->mmWidth, randrp->mmHeight);
-	if (!pSize)
-	    return FALSE;
-	RRRegisterRate (pScreen, pSize, refresh);
-
-	if (xf86ModesEqual(mode, scrp->currentMode))
-	{
-	    RRSetCurrentConfig (pScreen, randrp->rotation, refresh, pSize);
-	}
-	if (mode->next == scrp->modes)
-	    break;
+    for (mode = scrp->modes;; mode = mode->next) {
+        int refresh = xf86RandR12ModeRefresh(mode);
+
+        if (randrp->maxX == 0 || randrp->maxY == 0) {
+            if (maxX < mode->HDisplay)
+                maxX = mode->HDisplay;
+            if (maxY < mode->VDisplay)
+                maxY = mode->VDisplay;
+        }
+        if (mode == scrp->modes)
+            refresh0 = refresh;
+        pSize = RRRegisterSize(pScreen,
+                               mode->HDisplay, mode->VDisplay,
+                               randrp->mmWidth, randrp->mmHeight);
+        if (!pSize)
+            return FALSE;
+        RRRegisterRate(pScreen, pSize, refresh);
+
+        if (xf86ModesEqual(mode, scrp->currentMode)) {
+            RRSetCurrentConfig(pScreen, randrp->rotation, refresh, pSize);
+        }
+        if (mode->next == scrp->modes)
+            break;
     }
 
-    if (randrp->maxX == 0 || randrp->maxY == 0)
-    {
-	randrp->maxX = maxX;
-	randrp->maxY = maxY;
+    if (randrp->maxX == 0 || randrp->maxY == 0) {
+        randrp->maxX = maxX;
+        randrp->maxY = maxY;
     }
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12SetMode (ScreenPtr	    pScreen,
-		  DisplayModePtr    mode,
-		  Bool		    useVirtual,
-		  int		    mmWidth,
-		  int		    mmHeight)
+xf86RandR12SetMode(ScreenPtr pScreen,
+                   DisplayModePtr mode,
+                   Bool useVirtual, int mmWidth, int mmHeight)
 {
-    ScrnInfoPtr		scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    int			oldWidth = pScreen->width;
-    int			oldHeight = pScreen->height;
-    int			oldmmWidth = pScreen->mmWidth;
-    int			oldmmHeight = pScreen->mmHeight;
-    WindowPtr		pRoot = pScreen->root;
-    DisplayModePtr      currentMode = NULL;
-    Bool 		ret = TRUE;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    int oldWidth = pScreen->width;
+    int oldHeight = pScreen->height;
+    int oldmmWidth = pScreen->mmWidth;
+    int oldmmHeight = pScreen->mmHeight;
+    WindowPtr pRoot = pScreen->root;
+    DisplayModePtr currentMode = NULL;
+    Bool ret = TRUE;
 
     if (pRoot)
-	(*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
-    if (useVirtual)
-    {
-	scrp->virtualX = randrp->virtualX;
-	scrp->virtualY = randrp->virtualY;
+        (*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
+    if (useVirtual) {
+        scrp->virtualX = randrp->virtualX;
+        scrp->virtualY = randrp->virtualY;
     }
-    else
-    {
-	scrp->virtualX = mode->HDisplay;
-	scrp->virtualY = mode->VDisplay;
+    else {
+        scrp->virtualX = mode->HDisplay;
+        scrp->virtualY = mode->VDisplay;
     }
 
-    if(randrp->rotation & (RR_Rotate_90 | RR_Rotate_270))
-    {
-	/* If the screen is rotated 90 or 270 degrees, swap the sizes. */
-	pScreen->width = scrp->virtualY;
-	pScreen->height = scrp->virtualX;
-	pScreen->mmWidth = mmHeight;
-	pScreen->mmHeight = mmWidth;
+    if (randrp->rotation & (RR_Rotate_90 | RR_Rotate_270)) {
+        /* If the screen is rotated 90 or 270 degrees, swap the sizes. */
+        pScreen->width = scrp->virtualY;
+        pScreen->height = scrp->virtualX;
+        pScreen->mmWidth = mmHeight;
+        pScreen->mmHeight = mmWidth;
     }
-    else
-    {
-	pScreen->width = scrp->virtualX;
-	pScreen->height = scrp->virtualY;
-	pScreen->mmWidth = mmWidth;
-	pScreen->mmHeight = mmHeight;
+    else {
+        pScreen->width = scrp->virtualX;
+        pScreen->height = scrp->virtualY;
+        pScreen->mmWidth = mmWidth;
+        pScreen->mmHeight = mmHeight;
     }
     if (scrp->currentMode == mode) {
         /* Save current mode */
@@ -549,13 +548,12 @@ xf86RandR12SetMode (ScreenPtr	    pScreen,
      * We know that if the driver failed to SwitchMode to the rotated
      * version, then it should revert back to it's prior mode.
      */
-    if (!xf86SwitchMode (pScreen, mode))
-    {
+    if (!xf86SwitchMode(pScreen, mode)) {
         ret = FALSE;
-	scrp->virtualX = pScreen->width = oldWidth;
-	scrp->virtualY = pScreen->height = oldHeight;
-	pScreen->mmWidth = oldmmWidth;
-	pScreen->mmHeight = oldmmHeight;
+        scrp->virtualX = pScreen->width = oldWidth;
+        scrp->virtualY = pScreen->height = oldHeight;
+        pScreen->mmWidth = oldmmWidth;
+        pScreen->mmHeight = oldmmHeight;
         scrp->currentMode = currentMode;
     }
 
@@ -567,182 +565,169 @@ xf86RandR12SetMode (ScreenPtr	    pScreen,
     /*
      * Make sure the whole screen is visible
      */
-    xf86SetViewport (pScreen, pScreen->width, pScreen->height);
-    xf86SetViewport (pScreen, 0, 0);
+    xf86SetViewport(pScreen, pScreen->width, pScreen->height);
+    xf86SetViewport(pScreen, 0, 0);
     if (pRoot)
-	(*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
+        (*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
     return ret;
 }
 
 Bool
-xf86RandR12SetConfig (ScreenPtr		pScreen,
-		    Rotation		rotation,
-		    int			rate,
-		    RRScreenSizePtr	pSize)
+xf86RandR12SetConfig(ScreenPtr pScreen,
+                     Rotation rotation, int rate, RRScreenSizePtr pSize)
 {
-    ScrnInfoPtr		scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    DisplayModePtr	mode;
-    int			pos[MAXDEVICES][2];
-    Bool		useVirtual = FALSE;
-    int			maxX = 0, maxY = 0;
-    Rotation		oldRotation = randrp->rotation;
-    DeviceIntPtr	dev;
-    Bool		view_adjusted = FALSE;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    DisplayModePtr mode;
+    int pos[MAXDEVICES][2];
+    Bool useVirtual = FALSE;
+    int maxX = 0, maxY = 0;
+    Rotation oldRotation = randrp->rotation;
+    DeviceIntPtr dev;
+    Bool view_adjusted = FALSE;
 
     randrp->rotation = rotation;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = scrp->virtualX;
-	randrp->virtualY = scrp->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = scrp->virtualX;
+        randrp->virtualY = scrp->virtualY;
     }
 
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-	if (!IsMaster(dev) && !IsFloating(dev))
-		continue;
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if (!IsMaster(dev) && !IsFloating(dev))
+            continue;
 
-	miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
+        miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
     }
 
-    for (mode = scrp->modes; ; mode = mode->next)
-    {
-	if (randrp->maxX == 0 || randrp->maxY == 0)
-	{
-		if (maxX < mode->HDisplay)
-			maxX = mode->HDisplay;
-		if (maxY < mode->VDisplay)
-			maxY = mode->VDisplay;
-	}
-	if (mode->HDisplay == pSize->width &&
-	    mode->VDisplay == pSize->height &&
-	    (rate == 0 || xf86RandR12ModeRefresh (mode) == rate))
-	    break;
-	if (mode->next == scrp->modes)
-	{
-	    if (pSize->width == randrp->virtualX &&
-		pSize->height == randrp->virtualY)
-	    {
-		mode = scrp->modes;
-		useVirtual = TRUE;
-		break;
-	    }
-    	    if (randrp->maxX == 0 || randrp->maxY == 0)
-    	    {
-		randrp->maxX = maxX;
-		randrp->maxY = maxY;
-    	    }
-	    return FALSE;
-	}
+    for (mode = scrp->modes;; mode = mode->next) {
+        if (randrp->maxX == 0 || randrp->maxY == 0) {
+            if (maxX < mode->HDisplay)
+                maxX = mode->HDisplay;
+            if (maxY < mode->VDisplay)
+                maxY = mode->VDisplay;
+        }
+        if (mode->HDisplay == pSize->width &&
+            mode->VDisplay == pSize->height &&
+            (rate == 0 || xf86RandR12ModeRefresh(mode) == rate))
+            break;
+        if (mode->next == scrp->modes) {
+            if (pSize->width == randrp->virtualX &&
+                pSize->height == randrp->virtualY) {
+                mode = scrp->modes;
+                useVirtual = TRUE;
+                break;
+            }
+            if (randrp->maxX == 0 || randrp->maxY == 0) {
+                randrp->maxX = maxX;
+                randrp->maxY = maxY;
+            }
+            return FALSE;
+        }
     }
 
-    if (randrp->maxX == 0 || randrp->maxY == 0)
-    {
-	randrp->maxX = maxX;
-	randrp->maxY = maxY;
+    if (randrp->maxX == 0 || randrp->maxY == 0) {
+        randrp->maxX = maxX;
+        randrp->maxY = maxY;
     }
 
-    if (!xf86RandR12SetMode (pScreen, mode, useVirtual, pSize->mmWidth,
-			   pSize->mmHeight)) {
+    if (!xf86RandR12SetMode(pScreen, mode, useVirtual, pSize->mmWidth,
+                            pSize->mmHeight)) {
         randrp->rotation = oldRotation;
-	return FALSE;
+        return FALSE;
     }
 
     /*
      * Move the cursor back where it belongs; SwitchMode repositions it
      * FIXME: duplicated code, see modes/xf86RandR12.c
      */
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-	if (!IsMaster(dev) && !IsFloating(dev))
-		continue;
-
-	if (pScreen == miPointerGetScreen(dev)) {
-	    int px = pos[dev->id][0];
-	    int py = pos[dev->id][1];
-
-	    px = (px >= pScreen->width ? (pScreen->width - 1) : px);
-	    py = (py >= pScreen->height ? (pScreen->height - 1) : py);
-
-	    /* Setting the viewpoint makes only sense on one device */
-	    if (!view_adjusted && IsMaster(dev)) {
-		xf86SetViewport(pScreen, px, py);
-		view_adjusted = TRUE;
-	    }
-
-	    (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
-	}
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if (!IsMaster(dev) && !IsFloating(dev))
+            continue;
+
+        if (pScreen == miPointerGetScreen(dev)) {
+            int px = pos[dev->id][0];
+            int py = pos[dev->id][1];
+
+            px = (px >= pScreen->width ? (pScreen->width - 1) : px);
+            py = (py >= pScreen->height ? (pScreen->height - 1) : py);
+
+            /* Setting the viewpoint makes only sense on one device */
+            if (!view_adjusted && IsMaster(dev)) {
+                xf86SetViewport(pScreen, px, py);
+                view_adjusted = TRUE;
+            }
+
+            (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
+        }
     }
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12ScreenSetSize (ScreenPtr	pScreen,
-			CARD16		width,
-			CARD16		height,
-			CARD32		mmWidth,
-			CARD32		mmHeight)
+xf86RandR12ScreenSetSize(ScreenPtr pScreen,
+                         CARD16 width,
+                         CARD16 height, CARD32 mmWidth, CARD32 mmHeight)
 {
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    ScrnInfoPtr		pScrn = XF86SCRNINFO(pScreen);
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);
-    WindowPtr		pRoot = pScreen->root;
-    PixmapPtr		pScrnPix;
-    Bool		ret = FALSE;
-    int                 c;
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    WindowPtr pRoot = pScreen->root;
+    PixmapPtr pScrnPix;
+    Bool ret = FALSE;
+    int c;
 
     if (xf86RandR12Key) {
-        if (randrp->virtualX == -1 || randrp->virtualY == -1)
-        {
-	    randrp->virtualX = pScrn->virtualX;
-	    randrp->virtualY = pScrn->virtualY;
+        if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+            randrp->virtualX = pScrn->virtualX;
+            randrp->virtualY = pScrn->virtualY;
         }
     }
     if (pRoot && pScrn->vtSema)
-	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);
+        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);
 
     /* Let the driver update virtualX and virtualY */
-    if (!(*config->funcs->resize)(pScrn, width, height))
-	goto finish;
+    if (!(*config->funcs->resize) (pScrn, width, height))
+        goto finish;
 
     ret = TRUE;
     /* Update panning information */
     for (c = 0; c < config->num_crtc; c++) {
-	xf86CrtcPtr crtc = config->crtc[c];
-	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1 ||
-	    crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
-	    if (crtc->panningTotalArea.x2 > crtc->panningTrackingArea.x1)
-		crtc->panningTotalArea.x2 += width  - pScreen->width;
-	    if (crtc->panningTotalArea.y2 > crtc->panningTrackingArea.y1)
-		crtc->panningTotalArea.y2 += height - pScreen->height;
-	    if (crtc->panningTrackingArea.x2 > crtc->panningTrackingArea.x1)
-		crtc->panningTrackingArea.x2 += width  - pScreen->width;
-	    if (crtc->panningTrackingArea.y2 > crtc->panningTrackingArea.y1)
-		crtc->panningTrackingArea.y2 += height - pScreen->height;
-	    xf86RandR13VerifyPanningArea (crtc, width, height);
-	    xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
-	}
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1 ||
+            crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+            if (crtc->panningTotalArea.x2 > crtc->panningTrackingArea.x1)
+                crtc->panningTotalArea.x2 += width - pScreen->width;
+            if (crtc->panningTotalArea.y2 > crtc->panningTrackingArea.y1)
+                crtc->panningTotalArea.y2 += height - pScreen->height;
+            if (crtc->panningTrackingArea.x2 > crtc->panningTrackingArea.x1)
+                crtc->panningTrackingArea.x2 += width - pScreen->width;
+            if (crtc->panningTrackingArea.y2 > crtc->panningTrackingArea.y1)
+                crtc->panningTrackingArea.y2 += height - pScreen->height;
+            xf86RandR13VerifyPanningArea(crtc, width, height);
+            xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
+        }
     }
 
-    pScrnPix = (*pScreen->GetScreenPixmap)(pScreen);
+    pScrnPix = (*pScreen->GetScreenPixmap) (pScreen);
     pScreen->width = pScrnPix->drawable.width = width;
     pScreen->height = pScrnPix->drawable.height = height;
     randrp->mmWidth = pScreen->mmWidth = mmWidth;
     randrp->mmHeight = pScreen->mmHeight = mmHeight;
 
-    xf86SetViewport (pScreen, pScreen->width-1, pScreen->height-1);
-    xf86SetViewport (pScreen, 0, 0);
+    xf86SetViewport(pScreen, pScreen->width - 1, pScreen->height - 1);
+    xf86SetViewport(pScreen, 0, 0);
 
-finish:
+ finish:
     update_desktop_dimensions();
 
     if (pRoot && pScrn->vtSema)
-	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
+        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
 #if RANDR_12_INTERFACE
     if (xf86RandR12Key && pScreen->root && ret)
-	RRScreenSizeNotify (pScreen);
+        RRScreenSizeNotify(pScreen);
 #endif
     return ret;
 }
@@ -750,24 +735,25 @@ finish:
 Rotation
 xf86RandR12GetRotation(ScreenPtr pScreen)
 {
-    XF86RandRInfoPtr	    randrp = XF86RANDRINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
 
     return randrp->rotation;
 }
 
 Bool
-xf86RandR12CreateScreenResources (ScreenPtr pScreen)
+xf86RandR12CreateScreenResources(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config;
-    XF86RandRInfoPtr	randrp;
-    int			c;
-    int			width, height;
-    int			mmWidth, mmHeight;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config;
+    XF86RandRInfoPtr randrp;
+    int c;
+    int width, height;
+    int mmWidth, mmHeight;
+
 #ifdef PANORAMIX
     /* XXX disable RandR when using Xinerama */
     if (!noPanoramiXExtension)
-	return TRUE;
+        return TRUE;
 #endif
 
     config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -775,103 +761,91 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
     /*
      * Compute size of screen
      */
-    width = 0; height = 0;
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = config->crtc[c];
-	int	    crtc_width = crtc->x + xf86ModeWidth (&crtc->mode, crtc->rotation);
-	int	    crtc_height = crtc->y + xf86ModeHeight (&crtc->mode, crtc->rotation);
-	
-	if (crtc->enabled) {
-	    if (crtc_width > width)
-		width = crtc_width;
-	    if (crtc_height > height)
-		height = crtc_height;
-	    if (crtc->panningTotalArea.x2 > width)
-		width = crtc->panningTotalArea.x2;
-	    if (crtc->panningTotalArea.y2 > height)
-		height = crtc->panningTotalArea.y2;
-	}
+    width = 0;
+    height = 0;
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+        int crtc_width = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
+        int crtc_height = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);
+
+        if (crtc->enabled) {
+            if (crtc_width > width)
+                width = crtc_width;
+            if (crtc_height > height)
+                height = crtc_height;
+            if (crtc->panningTotalArea.x2 > width)
+                width = crtc->panningTotalArea.x2;
+            if (crtc->panningTotalArea.y2 > height)
+                height = crtc->panningTotalArea.y2;
+        }
     }
-    
-    if (width && height)
-    {
-	/*
-	 * Compute physical size of screen
-	 */
-	if (monitorResolution) 
-	{
-	    mmWidth = width * 25.4 / monitorResolution;
-	    mmHeight = height * 25.4 / monitorResolution;
-	}
-	else
-	{
-	    xf86OutputPtr   output = xf86CompatOutput(pScrn);
-
-	    if (output &&
-		output->conf_monitor &&
-		(output->conf_monitor->mon_width  > 0 &&
-		 output->conf_monitor->mon_height > 0))
-	    {
-		/*
-		 * Prefer user configured DisplaySize
-		 */
-		mmWidth = output->conf_monitor->mon_width;
-		mmHeight = output->conf_monitor->mon_height;
-	    }
-	    else
-	    {
-		/*
-		 * Otherwise, just set the screen to DEFAULT_DPI
-		 */
-		mmWidth = width * 25.4 / DEFAULT_DPI;
-		mmHeight = height * 25.4 / DEFAULT_DPI;
-	    }
-	}
-	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-		   "Setting screen physical size to %d x %d\n",
-		   mmWidth, mmHeight);
-	/*
-	 * This is the initial setting of the screen size.
-	 * We have to pre-set it here, otherwise panning would be adapted
-	 * to the new screen size.
-	 */
-	pScreen->width  = width;
-	pScreen->height = height;
-	xf86RandR12ScreenSetSize (pScreen,
-				  width,
-				  height,
-				  mmWidth,
-				  mmHeight);
+
+    if (width && height) {
+        /*
+         * Compute physical size of screen
+         */
+        if (monitorResolution) {
+            mmWidth = width * 25.4 / monitorResolution;
+            mmHeight = height * 25.4 / monitorResolution;
+        }
+        else {
+            xf86OutputPtr output = xf86CompatOutput(pScrn);
+
+            if (output &&
+                output->conf_monitor &&
+                (output->conf_monitor->mon_width > 0 &&
+                 output->conf_monitor->mon_height > 0)) {
+                /*
+                 * Prefer user configured DisplaySize
+                 */
+                mmWidth = output->conf_monitor->mon_width;
+                mmHeight = output->conf_monitor->mon_height;
+            }
+            else {
+                /*
+                 * Otherwise, just set the screen to DEFAULT_DPI
+                 */
+                mmWidth = width * 25.4 / DEFAULT_DPI;
+                mmHeight = height * 25.4 / DEFAULT_DPI;
+            }
+        }
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                   "Setting screen physical size to %d x %d\n",
+                   mmWidth, mmHeight);
+        /*
+         * This is the initial setting of the screen size.
+         * We have to pre-set it here, otherwise panning would be adapted
+         * to the new screen size.
+         */
+        pScreen->width = width;
+        pScreen->height = height;
+        xf86RandR12ScreenSetSize(pScreen, width, height, mmWidth, mmHeight);
     }
 
     if (xf86RandR12Key == NULL)
-	return TRUE;
+        return TRUE;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = pScrn->virtualX;
-	randrp->virtualY = pScrn->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = pScrn->virtualX;
+        randrp->virtualY = pScrn->virtualY;
     }
-    xf86CrtcSetScreenSubpixelOrder (pScreen);
+    xf86CrtcSetScreenSubpixelOrder(pScreen);
 #if RANDR_12_INTERFACE
-    if (xf86RandR12CreateScreenResources12 (pScreen))
-	return TRUE;
+    if (xf86RandR12CreateScreenResources12(pScreen))
+        return TRUE;
 #endif
     return TRUE;
 }
 
-
 Bool
-xf86RandR12Init (ScreenPtr pScreen)
+xf86RandR12Init(ScreenPtr pScreen)
 {
-    rrScrPrivPtr	rp;
-    XF86RandRInfoPtr	randrp;
+    rrScrPrivPtr rp;
+    XF86RandRInfoPtr randrp;
 
 #ifdef PANORAMIX
     /* XXX disable RandR when using Xinerama */
-    if (!noPanoramiXExtension)
-    {
+    if (!noPanoramiXExtension) {
         if (xf86NumScreens == 1)
             noPanoramiXExtension = TRUE;
         else
@@ -880,20 +854,19 @@ xf86RandR12Init (ScreenPtr pScreen)
 #endif
 
     if (xf86RandR12Generation != serverGeneration)
-	xf86RandR12Generation = serverGeneration;
+        xf86RandR12Generation = serverGeneration;
 
     xf86RandR12Key = &xf86RandR12KeyRec;
     if (!dixRegisterPrivateKey(&xf86RandR12KeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
-    randrp = malloc(sizeof (XF86RandRInfoRec));
+    randrp = malloc(sizeof(XF86RandRInfoRec));
     if (!randrp)
-	return FALSE;
+        return FALSE;
 
-    if (!RRScreenInit(pScreen))
-    {
-	free(randrp);
-	return FALSE;
+    if (!RRScreenInit(pScreen)) {
+        free(randrp);
+        return FALSE;
     }
     rp = rrGetScrPriv(pScreen);
     rp->rrGetInfo = xf86RandR12GetInfo;
@@ -904,7 +877,7 @@ xf86RandR12Init (ScreenPtr pScreen)
     randrp->mmWidth = pScreen->mmWidth;
     randrp->mmHeight = pScreen->mmHeight;
 
-    randrp->rotation = RR_Rotate_0; /* initial rotated mode */
+    randrp->rotation = RR_Rotate_0;     /* initial rotated mode */
 
     randrp->supported_rotations = RR_Rotate_0;
 
@@ -913,19 +886,19 @@ xf86RandR12Init (ScreenPtr pScreen)
     dixSetPrivate(&pScreen->devPrivates, xf86RandR12Key, randrp);
 
 #if RANDR_12_INTERFACE
-    if (!xf86RandR12Init12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12Init12(pScreen))
+        return FALSE;
 #endif
     return TRUE;
 }
 
 void
-xf86RandR12CloseScreen (ScreenPtr pScreen)
+xf86RandR12CloseScreen(ScreenPtr pScreen)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_12_INTERFACE
@@ -936,48 +909,50 @@ xf86RandR12CloseScreen (ScreenPtr pScreen)
 }
 
 void
-xf86RandR12SetRotations (ScreenPtr pScreen, Rotation rotations)
+xf86RandR12SetRotations(ScreenPtr pScreen, Rotation rotations)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
+
 #if RANDR_12_INTERFACE
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    int			c;
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    int c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 #endif
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_12_INTERFACE
     for (c = 0; c < config->num_crtc; c++) {
-	xf86CrtcPtr    crtc = config->crtc[c];
+        xf86CrtcPtr crtc = config->crtc[c];
 
-	RRCrtcSetRotations (crtc->randr_crtc, rotations);
+        RRCrtcSetRotations(crtc->randr_crtc, rotations);
     }
 #endif
     randrp->supported_rotations = rotations;
 }
 
 void
-xf86RandR12SetTransformSupport (ScreenPtr pScreen, Bool transforms)
+xf86RandR12SetTransformSupport(ScreenPtr pScreen, Bool transforms)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
+
 #if RANDR_13_INTERFACE
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    int			c;
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    int c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 #endif
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_13_INTERFACE
     for (c = 0; c < config->num_crtc; c++) {
-	xf86CrtcPtr    crtc = config->crtc[c];
+        xf86CrtcPtr crtc = config->crtc[c];
 
-	RRCrtcSetTransformSupport (crtc->randr_crtc, transforms);
+        RRCrtcSetTransformSupport(crtc->randr_crtc, transforms);
     }
 #endif
 }
@@ -988,15 +963,15 @@ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
     ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
 
     if (xf86RandR12Generation != serverGeneration ||
-	XF86RANDRINFO(pScreen)->virtualX == -1)
-    {
-	*x = pScrn->virtualX;
-	*y = pScrn->virtualY;
-    } else {
-	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
-
-	*x = randrp->virtualX;
-	*y = randrp->virtualY;
+        XF86RANDRINFO(pScreen)->virtualX == -1) {
+        *x = pScrn->virtualX;
+        *y = pScrn->virtualY;
+    }
+    else {
+        XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+
+        *x = randrp->virtualX;
+        *y = randrp->virtualY;
     }
 }
 
@@ -1018,95 +993,106 @@ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
 		   RR_ClockDivideBy2)
 
 static Bool
-xf86RandRModeMatches (RRModePtr		randr_mode,
-		      DisplayModePtr	mode)
+xf86RandRModeMatches(RRModePtr randr_mode, DisplayModePtr mode)
 {
 #if 0
-    if (match_name)
-    {
-	/* check for same name */
-	int	len = strlen (mode->name);
-	if (randr_mode->mode.nameLength != len)			return FALSE;
-	if (memcmp (randr_mode->name, mode->name, len) != 0)	return FALSE;
+    if (match_name) {
+        /* check for same name */
+        int len = strlen(mode->name);
+
+        if (randr_mode->mode.nameLength != len)
+            return FALSE;
+        if (memcmp(randr_mode->name, mode->name, len) != 0)
+            return FALSE;
     }
 #endif
-    
+
     /* check for same timings */
-    if (randr_mode->mode.dotClock / 1000 != mode->Clock)    return FALSE;
-    if (randr_mode->mode.width        != mode->HDisplay)    return FALSE;
-    if (randr_mode->mode.hSyncStart   != mode->HSyncStart)  return FALSE;
-    if (randr_mode->mode.hSyncEnd     != mode->HSyncEnd)    return FALSE;
-    if (randr_mode->mode.hTotal       != mode->HTotal)	    return FALSE;
-    if (randr_mode->mode.hSkew        != mode->HSkew)	    return FALSE;
-    if (randr_mode->mode.height       != mode->VDisplay)    return FALSE;
-    if (randr_mode->mode.vSyncStart   != mode->VSyncStart)  return FALSE;
-    if (randr_mode->mode.vSyncEnd     != mode->VSyncEnd)    return FALSE;
-    if (randr_mode->mode.vTotal       != mode->VTotal)	    return FALSE;
-    
+    if (randr_mode->mode.dotClock / 1000 != mode->Clock)
+        return FALSE;
+    if (randr_mode->mode.width != mode->HDisplay)
+        return FALSE;
+    if (randr_mode->mode.hSyncStart != mode->HSyncStart)
+        return FALSE;
+    if (randr_mode->mode.hSyncEnd != mode->HSyncEnd)
+        return FALSE;
+    if (randr_mode->mode.hTotal != mode->HTotal)
+        return FALSE;
+    if (randr_mode->mode.hSkew != mode->HSkew)
+        return FALSE;
+    if (randr_mode->mode.height != mode->VDisplay)
+        return FALSE;
+    if (randr_mode->mode.vSyncStart != mode->VSyncStart)
+        return FALSE;
+    if (randr_mode->mode.vSyncEnd != mode->VSyncEnd)
+        return FALSE;
+    if (randr_mode->mode.vTotal != mode->VTotal)
+        return FALSE;
+
     /* check for same flags (using only the XF86 valid flag bits) */
     if ((randr_mode->mode.modeFlags & FLAG_BITS) != (mode->Flags & FLAG_BITS))
-	return FALSE;
-    
+        return FALSE;
+
     /* everything matches */
     return TRUE;
 }
 
 static Bool
-xf86RandR12CrtcNotify (RRCrtcPtr	randr_crtc)
+xf86RandR12CrtcNotify(RRCrtcPtr randr_crtc)
 {
-    ScreenPtr		pScreen = randr_crtc->pScreen;
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    RRModePtr		randr_mode = NULL;
-    int			x;
-    int			y;
-    Rotation		rotation;
-    int			numOutputs;
-    RROutputPtr		*randr_outputs;
-    RROutputPtr		randr_output;
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
-    xf86OutputPtr	output;
-    int			i, j;
-    DisplayModePtr	mode = &crtc->mode;
-    Bool		ret;
-
-    randr_outputs = malloc(config->num_output * sizeof (RROutputPtr));
+    ScreenPtr pScreen = randr_crtc->pScreen;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    RRModePtr randr_mode = NULL;
+    int x;
+    int y;
+    Rotation rotation;
+    int numOutputs;
+    RROutputPtr *randr_outputs;
+    RROutputPtr randr_output;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    xf86OutputPtr output;
+    int i, j;
+    DisplayModePtr mode = &crtc->mode;
+    Bool ret;
+
+    randr_outputs = malloc(config->num_output * sizeof(RROutputPtr));
     if (!randr_outputs)
-	return FALSE;
+        return FALSE;
     x = crtc->x;
     y = crtc->y;
     rotation = crtc->rotation;
     numOutputs = 0;
     randr_mode = NULL;
-    for (i = 0; i < config->num_output; i++)
-    {
-	output = config->output[i];
-	if (output->crtc == crtc)
-	{
-	    randr_output = output->randr_output;
-	    randr_outputs[numOutputs++] = randr_output;
-	    /*
-	     * We make copies of modes, so pointer equality 
-	     * isn't sufficient
-	     */
-	    for (j = 0; j < randr_output->numModes + randr_output->numUserModes; j++)
-	    {
-		RRModePtr   m = (j < randr_output->numModes ?
-				 randr_output->modes[j] :
-				 randr_output->userModes[j-randr_output->numModes]);
-					 
-		if (xf86RandRModeMatches (m, mode))
-		{
-		    randr_mode = m;
-		    break;
-		}
-	    }
-	}
+    for (i = 0; i < config->num_output; i++) {
+        output = config->output[i];
+        if (output->crtc == crtc) {
+            randr_output = output->randr_output;
+            randr_outputs[numOutputs++] = randr_output;
+            /*
+             * We make copies of modes, so pointer equality 
+             * isn't sufficient
+             */
+            for (j = 0; j < randr_output->numModes + randr_output->numUserModes;
+                 j++) {
+                RRModePtr m =
+                    (j <
+                     randr_output->numModes ? randr_output->
+                     modes[j] : randr_output->userModes[j -
+                                                        randr_output->
+                                                        numModes]);
+
+                if (xf86RandRModeMatches(m, mode)) {
+                    randr_mode = m;
+                    break;
+                }
+            }
+        }
     }
-    ret = RRCrtcNotify (randr_crtc, randr_mode, x, y,
-			rotation, 
-			crtc->transformPresent ? &crtc->transform : NULL,
-			numOutputs, randr_outputs);
+    ret = RRCrtcNotify(randr_crtc, randr_mode, x, y,
+                       rotation,
+                       crtc->transformPresent ? &crtc->transform : NULL,
+                       numOutputs, randr_outputs);
     free(randr_outputs);
     return ret;
 }
@@ -1115,21 +1101,20 @@ xf86RandR12CrtcNotify (RRCrtcPtr	randr_crtc)
  * Convert a RandR mode to a DisplayMode
  */
 static void
-xf86RandRModeConvert (ScrnInfoPtr	scrn,
-		      RRModePtr		randr_mode,
-		      DisplayModePtr	mode)
+xf86RandRModeConvert(ScrnInfoPtr scrn,
+                     RRModePtr randr_mode, DisplayModePtr mode)
 {
     memset(mode, 0, sizeof(DisplayModeRec));
     mode->status = MODE_OK;
 
     mode->Clock = randr_mode->mode.dotClock / 1000;
-    
+
     mode->HDisplay = randr_mode->mode.width;
     mode->HSyncStart = randr_mode->mode.hSyncStart;
     mode->HSyncEnd = randr_mode->mode.hSyncEnd;
     mode->HTotal = randr_mode->mode.hTotal;
     mode->HSkew = randr_mode->mode.hSkew;
-    
+
     mode->VDisplay = randr_mode->mode.height;
     mode->VSyncStart = randr_mode->mode.vSyncStart;
     mode->VSyncEnd = randr_mode->mode.vSyncEnd;
@@ -1138,137 +1123,134 @@ xf86RandRModeConvert (ScrnInfoPtr	scrn,
 
     mode->Flags = randr_mode->mode.modeFlags & FLAG_BITS;
 
-    xf86SetModeCrtc (mode, scrn->adjustFlags);
+    xf86SetModeCrtc(mode, scrn->adjustFlags);
 }
 
 static Bool
-xf86RandR12CrtcSet (ScreenPtr	    pScreen,
-		    RRCrtcPtr	    randr_crtc,
-		    RRModePtr	    randr_mode,
-		    int		    x,
-		    int		    y,
-		    Rotation	    rotation,
-		    int		    num_randr_outputs,
-		    RROutputPtr	    *randr_outputs)
+xf86RandR12CrtcSet(ScreenPtr pScreen,
+                   RRCrtcPtr randr_crtc,
+                   RRModePtr randr_mode,
+                   int x,
+                   int y,
+                   Rotation rotation,
+                   int num_randr_outputs, RROutputPtr * randr_outputs)
 {
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
-    RRTransformPtr	transform;
-    Bool		changed = FALSE;
-    int			o, ro;
-    xf86CrtcPtr		*save_crtcs;
-    Bool		save_enabled = crtc->enabled;
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    RRTransformPtr transform;
+    Bool changed = FALSE;
+    int o, ro;
+    xf86CrtcPtr *save_crtcs;
+    Bool save_enabled = crtc->enabled;
 
     if (!crtc->scrn->vtSema)
-	return FALSE;
+        return FALSE;
 
-    save_crtcs = malloc(config->num_output * sizeof (xf86CrtcPtr));
+    save_crtcs = malloc(config->num_output * sizeof(xf86CrtcPtr));
     if ((randr_mode != NULL) != crtc->enabled)
-	changed = TRUE;
-    else if (randr_mode && !xf86RandRModeMatches (randr_mode, &crtc->mode))
-	changed = TRUE;
-    
+        changed = TRUE;
+    else if (randr_mode && !xf86RandRModeMatches(randr_mode, &crtc->mode))
+        changed = TRUE;
+
     if (rotation != crtc->rotation)
-	changed = TRUE;
+        changed = TRUE;
 
-    transform = RRCrtcGetTransform (randr_crtc);
+    transform = RRCrtcGetTransform(randr_crtc);
     if ((transform != NULL) != crtc->transformPresent)
-	changed = TRUE;
-    else if (transform && memcmp (&transform->transform, &crtc->transform.transform,
-				  sizeof (transform->transform)) != 0)
-	changed = TRUE;
+        changed = TRUE;
+    else if (transform &&
+             memcmp(&transform->transform, &crtc->transform.transform,
+                    sizeof(transform->transform)) != 0)
+        changed = TRUE;
 
     if (x != crtc->x || y != crtc->y)
-	changed = TRUE;
-    for (o = 0; o < config->num_output; o++) 
-    {
-	xf86OutputPtr  output = config->output[o];
-	xf86CrtcPtr    new_crtc;
-
-	save_crtcs[o] = output->crtc;
-	
-	if (output->crtc == crtc)
-	    new_crtc = NULL;
-	else
-	    new_crtc = output->crtc;
-	for (ro = 0; ro < num_randr_outputs; ro++) 
-	    if (output->randr_output == randr_outputs[ro])
-	    {
-		new_crtc = crtc;
-		break;
-	    }
-	if (new_crtc != output->crtc)
-	{
-	    changed = TRUE;
-	    output->crtc = new_crtc;
-	}
+        changed = TRUE;
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        xf86CrtcPtr new_crtc;
+
+        save_crtcs[o] = output->crtc;
+
+        if (output->crtc == crtc)
+            new_crtc = NULL;
+        else
+            new_crtc = output->crtc;
+        for (ro = 0; ro < num_randr_outputs; ro++)
+            if (output->randr_output == randr_outputs[ro]) {
+                new_crtc = crtc;
+                break;
+            }
+        if (new_crtc != output->crtc) {
+            changed = TRUE;
+            output->crtc = new_crtc;
+        }
     }
-    for (ro = 0; ro < num_randr_outputs; ro++) 
+    for (ro = 0; ro < num_randr_outputs; ro++)
         if (randr_outputs[ro]->pendingProperties)
-	    changed = TRUE;
+            changed = TRUE;
 
     /* XXX need device-independent mode setting code through an API */
-    if (changed)
-    {
-	crtc->enabled = randr_mode != NULL;
-
-	if (randr_mode)
-	{
-	    DisplayModeRec  mode;
-	    RRTransformPtr  transform = RRCrtcGetTransform (randr_crtc);
-
-	    xf86RandRModeConvert (pScrn, randr_mode, &mode);
-	    if (!xf86CrtcSetModeTransform (crtc, &mode, rotation, transform, x, y))
-	    {
-		crtc->enabled = save_enabled;
-		for (o = 0; o < config->num_output; o++)
-		{
-		    xf86OutputPtr	output = config->output[o];
-		    output->crtc = save_crtcs[o];
-		}
-		free(save_crtcs);
-		return FALSE;
-	    }
-	    xf86RandR13VerifyPanningArea (crtc, pScreen->width, pScreen->height);
-	    xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
-	    /*
-	     * Save the last successful setting for EnterVT
-	     */
-	    crtc->desiredMode = mode;
-	    crtc->desiredRotation = rotation;
-	    if (transform) {
-		crtc->desiredTransform = *transform;
-		crtc->desiredTransformPresent = TRUE;
-	    } else
-		crtc->desiredTransformPresent = FALSE;
-
-	    crtc->desiredX = x;
-	    crtc->desiredY = y;
-	}
-	xf86DisableUnusedFunctions (pScrn);
+    if (changed) {
+        crtc->enabled = randr_mode != NULL;
+
+        if (randr_mode) {
+            DisplayModeRec mode;
+            RRTransformPtr transform = RRCrtcGetTransform(randr_crtc);
+
+            xf86RandRModeConvert(pScrn, randr_mode, &mode);
+            if (!xf86CrtcSetModeTransform
+                (crtc, &mode, rotation, transform, x, y)) {
+                crtc->enabled = save_enabled;
+                for (o = 0; o < config->num_output; o++) {
+                    xf86OutputPtr output = config->output[o];
+
+                    output->crtc = save_crtcs[o];
+                }
+                free(save_crtcs);
+                return FALSE;
+            }
+            xf86RandR13VerifyPanningArea(crtc, pScreen->width, pScreen->height);
+            xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
+            /*
+             * Save the last successful setting for EnterVT
+             */
+            crtc->desiredMode = mode;
+            crtc->desiredRotation = rotation;
+            if (transform) {
+                crtc->desiredTransform = *transform;
+                crtc->desiredTransformPresent = TRUE;
+            }
+            else
+                crtc->desiredTransformPresent = FALSE;
+
+            crtc->desiredX = x;
+            crtc->desiredY = y;
+        }
+        xf86DisableUnusedFunctions(pScrn);
     }
     free(save_crtcs);
-    return xf86RandR12CrtcNotify (randr_crtc);
+    return xf86RandR12CrtcNotify(randr_crtc);
 }
 
 static Bool
-xf86RandR12CrtcSetGamma (ScreenPtr    pScreen,
-			 RRCrtcPtr    randr_crtc)
+xf86RandR12CrtcSetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
 {
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
     if (crtc->funcs->gamma_set == NULL)
-	return FALSE;
+        return FALSE;
 
     if (!crtc->scrn->vtSema)
-	return TRUE;
+        return TRUE;
 
     /* Realloc local gamma if needed. */
     if (randr_crtc->gammaSize != crtc->gamma_size) {
         CARD16 *tmp_ptr;
-        tmp_ptr = realloc(crtc->gamma_red, 3 * crtc->gamma_size * sizeof (CARD16));
+
+        tmp_ptr =
+            realloc(crtc->gamma_red, 3 * crtc->gamma_size * sizeof(CARD16));
         if (!tmp_ptr)
             return FALSE;
         crtc->gamma_red = tmp_ptr;
@@ -1277,23 +1259,25 @@ xf86RandR12CrtcSetGamma (ScreenPtr    pScreen,
     }
 
     crtc->gamma_size = randr_crtc->gammaSize;
-    memcpy (crtc->gamma_red, randr_crtc->gammaRed, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_green, randr_crtc->gammaGreen, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_blue, randr_crtc->gammaBlue, crtc->gamma_size * sizeof (CARD16));
+    memcpy(crtc->gamma_red, randr_crtc->gammaRed,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_green, randr_crtc->gammaGreen,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_blue, randr_crtc->gammaBlue,
+           crtc->gamma_size * sizeof(CARD16));
 
     /* Only set it when the crtc is actually running.
      * Otherwise it will be set when it's activated.
      */
     if (crtc->active)
-	crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
-						crtc->gamma_blue, crtc->gamma_size);
+        crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
+                               crtc->gamma_blue, crtc->gamma_size);
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
-			 RRCrtcPtr    randr_crtc)
+xf86RandR12CrtcGetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
 {
     xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
@@ -1306,7 +1290,10 @@ xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
     /* Realloc randr gamma if needed. */
     if (randr_crtc->gammaSize != crtc->gamma_size) {
         CARD16 *tmp_ptr;
-        tmp_ptr = realloc(randr_crtc->gammaRed, 3 * crtc->gamma_size * sizeof (CARD16));
+
+        tmp_ptr =
+            realloc(randr_crtc->gammaRed,
+                    3 * crtc->gamma_size * sizeof(CARD16));
         if (!tmp_ptr)
             return FALSE;
         randr_crtc->gammaRed = tmp_ptr;
@@ -1314,18 +1301,20 @@ xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
         randr_crtc->gammaBlue = randr_crtc->gammaGreen + crtc->gamma_size;
     }
     randr_crtc->gammaSize = crtc->gamma_size;
-    memcpy (randr_crtc->gammaRed, crtc->gamma_red, crtc->gamma_size * sizeof (CARD16));
-    memcpy (randr_crtc->gammaGreen, crtc->gamma_green, crtc->gamma_size * sizeof (CARD16));
-    memcpy (randr_crtc->gammaBlue, crtc->gamma_blue, crtc->gamma_size * sizeof (CARD16));
+    memcpy(randr_crtc->gammaRed, crtc->gamma_red,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(randr_crtc->gammaGreen, crtc->gamma_green,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(randr_crtc->gammaBlue, crtc->gamma_blue,
+           crtc->gamma_size * sizeof(CARD16));
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12OutputSetProperty (ScreenPtr pScreen,
-			      RROutputPtr randr_output,
-			      Atom property,
-			      RRPropertyValuePtr value)
+xf86RandR12OutputSetProperty(ScreenPtr pScreen,
+                             RROutputPtr randr_output,
+                             Atom property, RRPropertyValuePtr value)
 {
     xf86OutputPtr output = randr_output->devPrivate;
 
@@ -1333,7 +1322,7 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
      * user is setting properties to.
      */
     if (output->funcs->set_property == NULL)
-	return TRUE;
+        return TRUE;
 
     /*
      * This function gets called even when vtSema is FALSE, as
@@ -1344,41 +1333,39 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
 }
 
 static Bool
-xf86RandR13OutputGetProperty (ScreenPtr pScreen,
-			      RROutputPtr randr_output,
-			      Atom property)
+xf86RandR13OutputGetProperty(ScreenPtr pScreen,
+                             RROutputPtr randr_output, Atom property)
 {
     xf86OutputPtr output = randr_output->devPrivate;
 
     if (output->funcs->get_property == NULL)
-	return TRUE;
+        return TRUE;
 
     /* Should be safe even w/o vtSema */
     return output->funcs->get_property(output, property);
 }
 
 static Bool
-xf86RandR12OutputValidateMode (ScreenPtr    pScreen,
-			       RROutputPtr  randr_output,
-			       RRModePtr    randr_mode)
+xf86RandR12OutputValidateMode(ScreenPtr pScreen,
+                              RROutputPtr randr_output, RRModePtr randr_mode)
 {
-    ScrnInfoPtr	    pScrn = xf86Screens[pScreen->myNum];
-    xf86OutputPtr   output = randr_output->devPrivate;
-    DisplayModeRec  mode;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86OutputPtr output = randr_output->devPrivate;
+    DisplayModeRec mode;
 
-    xf86RandRModeConvert (pScrn, randr_mode, &mode);
+    xf86RandRModeConvert(pScrn, randr_mode, &mode);
     /*
      * This function may be called when vtSema is FALSE, so
      * the underlying function must either avoid touching the hardware
      * or return FALSE when vtSema is FALSE
      */
-    if (output->funcs->mode_valid (output, &mode) != MODE_OK)
-	return FALSE;
+    if (output->funcs->mode_valid(output, &mode) != MODE_OK)
+        return FALSE;
     return TRUE;
 }
 
 static void
-xf86RandR12ModeDestroy (ScreenPtr pScreen, RRModePtr randr_mode)
+xf86RandR12ModeDestroy(ScreenPtr pScreen, RRModePtr randr_mode)
 {
 }
 
@@ -1387,56 +1374,56 @@ xf86RandR12ModeDestroy (ScreenPtr pScreen, RRModePtr randr_mode)
  * RandR modes and assign them to the output
  */
 static Bool
-xf86RROutputSetModes (RROutputPtr randr_output, DisplayModePtr modes)
+xf86RROutputSetModes(RROutputPtr randr_output, DisplayModePtr modes)
 {
-    DisplayModePtr  mode;
-    RRModePtr	    *rrmodes = NULL;
-    int		    nmode = 0;
-    int		    npreferred = 0;
-    Bool	    ret = TRUE;
-    int		    pref;
+    DisplayModePtr mode;
+    RRModePtr *rrmodes = NULL;
+    int nmode = 0;
+    int npreferred = 0;
+    Bool ret = TRUE;
+    int pref;
 
     for (mode = modes; mode; mode = mode->next)
-	nmode++;
+        nmode++;
 
     if (nmode) {
-	rrmodes = malloc(nmode * sizeof (RRModePtr));
-	
-	if (!rrmodes)
-	    return FALSE;
-	nmode = 0;
-
-	for (pref = 1; pref >= 0; pref--) {
-	    for (mode = modes; mode; mode = mode->next) {
-		if ((pref != 0) == ((mode->type & M_T_PREFERRED) != 0)) {
-		    xRRModeInfo		modeInfo;
-		    RRModePtr		rrmode;
-		    
-		    modeInfo.nameLength = strlen (mode->name);
-		    modeInfo.width = mode->HDisplay;
-		    modeInfo.dotClock = mode->Clock * 1000;
-		    modeInfo.hSyncStart = mode->HSyncStart;
-		    modeInfo.hSyncEnd = mode->HSyncEnd;
-		    modeInfo.hTotal = mode->HTotal;
-		    modeInfo.hSkew = mode->HSkew;
-
-		    modeInfo.height = mode->VDisplay;
-		    modeInfo.vSyncStart = mode->VSyncStart;
-		    modeInfo.vSyncEnd = mode->VSyncEnd;
-		    modeInfo.vTotal = mode->VTotal;
-		    modeInfo.modeFlags = mode->Flags;
-
-		    rrmode = RRModeGet (&modeInfo, mode->name);
-		    if (rrmode) {
-			rrmodes[nmode++] = rrmode;
-			npreferred += pref;
-		    }
-		}
-	    }
-	}
+        rrmodes = malloc(nmode * sizeof(RRModePtr));
+
+        if (!rrmodes)
+            return FALSE;
+        nmode = 0;
+
+        for (pref = 1; pref >= 0; pref--) {
+            for (mode = modes; mode; mode = mode->next) {
+                if ((pref != 0) == ((mode->type & M_T_PREFERRED) != 0)) {
+                    xRRModeInfo modeInfo;
+                    RRModePtr rrmode;
+
+                    modeInfo.nameLength = strlen(mode->name);
+                    modeInfo.width = mode->HDisplay;
+                    modeInfo.dotClock = mode->Clock * 1000;
+                    modeInfo.hSyncStart = mode->HSyncStart;
+                    modeInfo.hSyncEnd = mode->HSyncEnd;
+                    modeInfo.hTotal = mode->HTotal;
+                    modeInfo.hSkew = mode->HSkew;
+
+                    modeInfo.height = mode->VDisplay;
+                    modeInfo.vSyncStart = mode->VSyncStart;
+                    modeInfo.vSyncEnd = mode->VSyncEnd;
+                    modeInfo.vTotal = mode->VTotal;
+                    modeInfo.modeFlags = mode->Flags;
+
+                    rrmode = RRModeGet(&modeInfo, mode->name);
+                    if (rrmode) {
+                        rrmodes[nmode++] = rrmode;
+                        npreferred += pref;
+                    }
+                }
+            }
+        }
     }
-    
-    ret = RROutputSetModes (randr_output, rrmodes, nmode, npreferred);
+
+    ret = RROutputSetModes(randr_output, rrmodes, nmode, npreferred);
     free(rrmodes);
     return ret;
 }
@@ -1445,154 +1432,144 @@ xf86RROutputSetModes (RROutputPtr randr_output, DisplayModePtr modes)
  * Mirror the current mode configuration to RandR
  */
 static Bool
-xf86RandR12SetInfo12 (ScreenPtr pScreen)
+xf86RandR12SetInfo12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    RROutputPtr		*clones;
-    RRCrtcPtr		*crtcs;
-    int			ncrtc;
-    int			o, c, l;
-    RRCrtcPtr		randr_crtc;
-    int			nclone;
-    
-    clones = malloc(config->num_output * sizeof (RROutputPtr));
-    crtcs = malloc(config->num_crtc * sizeof (RRCrtcPtr));
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
-	
-	ncrtc = 0;
-	for (c = 0; c < config->num_crtc; c++)
-	    if (output->possible_crtcs & (1 << c))
-		crtcs[ncrtc++] = config->crtc[c]->randr_crtc;
-
-	if (output->crtc)
-	    randr_crtc = output->crtc->randr_crtc;
-	else
-	    randr_crtc = NULL;
-
-	if (!RROutputSetCrtcs (output->randr_output, crtcs, ncrtc))
-	{
-	    free(crtcs);
-	    free(clones);
-	    return FALSE;
-	}
-
-	RROutputSetPhysicalSize(output->randr_output, 
-				output->mm_width,
-				output->mm_height);
-	xf86RROutputSetModes (output->randr_output, output->probed_modes);
-
-	switch (output->status) {
-	case XF86OutputStatusConnected:
-	    RROutputSetConnection (output->randr_output, RR_Connected);
-	    break;
-	case XF86OutputStatusDisconnected:
-	    RROutputSetConnection (output->randr_output, RR_Disconnected);
-	    break;
-	case XF86OutputStatusUnknown:
-	    RROutputSetConnection (output->randr_output, RR_UnknownConnection);
-	    break;
-	}
-
-	RROutputSetSubpixelOrder (output->randr_output, output->subpixel_order);
-
-	/*
-	 * Valid clones
-	 */
-	nclone = 0;
-	for (l = 0; l < config->num_output; l++)
-	{
-	    xf86OutputPtr	    clone = config->output[l];
-	    
-	    if (l != o && (output->possible_clones & (1 << l)))
-		clones[nclone++] = clone->randr_output;
-	}
-	if (!RROutputSetClones (output->randr_output, clones, nclone))
-	{
-	    free(crtcs);
-	    free(clones);
-	    return FALSE;
-	}
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    RROutputPtr *clones;
+    RRCrtcPtr *crtcs;
+    int ncrtc;
+    int o, c, l;
+    RRCrtcPtr randr_crtc;
+    int nclone;
+
+    clones = malloc(config->num_output * sizeof(RROutputPtr));
+    crtcs = malloc(config->num_crtc * sizeof(RRCrtcPtr));
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+
+        ncrtc = 0;
+        for (c = 0; c < config->num_crtc; c++)
+            if (output->possible_crtcs & (1 << c))
+                crtcs[ncrtc++] = config->crtc[c]->randr_crtc;
+
+        if (output->crtc)
+            randr_crtc = output->crtc->randr_crtc;
+        else
+            randr_crtc = NULL;
+
+        if (!RROutputSetCrtcs(output->randr_output, crtcs, ncrtc)) {
+            free(crtcs);
+            free(clones);
+            return FALSE;
+        }
+
+        RROutputSetPhysicalSize(output->randr_output,
+                                output->mm_width, output->mm_height);
+        xf86RROutputSetModes(output->randr_output, output->probed_modes);
+
+        switch (output->status) {
+        case XF86OutputStatusConnected:
+            RROutputSetConnection(output->randr_output, RR_Connected);
+            break;
+        case XF86OutputStatusDisconnected:
+            RROutputSetConnection(output->randr_output, RR_Disconnected);
+            break;
+        case XF86OutputStatusUnknown:
+            RROutputSetConnection(output->randr_output, RR_UnknownConnection);
+            break;
+        }
+
+        RROutputSetSubpixelOrder(output->randr_output, output->subpixel_order);
+
+        /*
+         * Valid clones
+         */
+        nclone = 0;
+        for (l = 0; l < config->num_output; l++) {
+            xf86OutputPtr clone = config->output[l];
+
+            if (l != o && (output->possible_clones & (1 << l)))
+                clones[nclone++] = clone->randr_output;
+        }
+        if (!RROutputSetClones(output->randr_output, clones, nclone)) {
+            free(crtcs);
+            free(clones);
+            return FALSE;
+        }
     }
     free(crtcs);
     free(clones);
     return TRUE;
 }
 
-
-
 /*
  * Query the hardware for the current state, then mirror
  * that to RandR
  */
 static Bool
-xf86RandR12GetInfo12 (ScreenPtr pScreen, Rotation *rotations)
+xf86RandR12GetInfo12(ScreenPtr pScreen, Rotation * rotations)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 
     if (!pScrn->vtSema)
-	return TRUE;
-    xf86ProbeOutputModes (pScrn, 0, 0);
-    xf86SetScrnInfoModes (pScrn);
-    return xf86RandR12SetInfo12 (pScreen);
+        return TRUE;
+    xf86ProbeOutputModes(pScrn, 0, 0);
+    xf86SetScrnInfoModes(pScrn);
+    return xf86RandR12SetInfo12(pScreen);
 }
 
 static Bool
-xf86RandR12CreateObjects12 (ScreenPtr pScreen)
+xf86RandR12CreateObjects12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
-    int			o;
-    
-    if (!RRInit ())
-	return FALSE;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+    int o;
+
+    if (!RRInit())
+        return FALSE;
 
     /*
      * Configure crtcs
      */
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr    crtc = config->crtc[c];
-	
-	crtc->randr_crtc = RRCrtcCreate (pScreen, crtc);
-	RRCrtcGammaSetSize (crtc->randr_crtc, 256);
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        crtc->randr_crtc = RRCrtcCreate(pScreen, crtc);
+        RRCrtcGammaSetSize(crtc->randr_crtc, 256);
     }
     /*
      * Configure outputs
      */
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
 
-	output->randr_output = RROutputCreate (pScreen, output->name, 
-					       strlen (output->name),
-					       output);
+        output->randr_output = RROutputCreate(pScreen, output->name,
+                                              strlen(output->name), output);
 
-	if (output->funcs->create_resources != NULL)
-	    output->funcs->create_resources(output);
-	RRPostPendingProperties (output->randr_output);
+        if (output->funcs->create_resources != NULL)
+            output->funcs->create_resources(output);
+        RRPostPendingProperties(output->randr_output);
     }
     return TRUE;
 }
 
 static Bool
-xf86RandR12CreateScreenResources12 (ScreenPtr pScreen)
+xf86RandR12CreateScreenResources12(ScreenPtr pScreen)
 {
-    int			c;
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 
     if (xf86RandR12Key == NULL)
-	return TRUE;
+        return TRUE;
 
     for (c = 0; c < config->num_crtc; c++)
-        xf86RandR12CrtcNotify (config->crtc[c]->randr_crtc);
-    
-    RRScreenSetSizeRange (pScreen, config->minWidth, config->minHeight,
-			  config->maxWidth, config->maxHeight);
+        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);
+
+    RRScreenSetSizeRange(pScreen, config->minWidth, config->minHeight,
+                         config->maxWidth, config->maxHeight);
     return TRUE;
 }
 
@@ -1602,95 +1579,91 @@ xf86RandR12CreateScreenResources12 (ScreenPtr pScreen)
  */
 
 void
-xf86RandR12TellChanged (ScreenPtr pScreen)
+xf86RandR12TellChanged(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
-    xf86RandR12SetInfo12 (pScreen);
+    xf86RandR12SetInfo12(pScreen);
     for (c = 0; c < config->num_crtc; c++)
-	xf86RandR12CrtcNotify (config->crtc[c]->randr_crtc);
+        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);
 
-    RRTellChanged (pScreen);
+    RRTellChanged(pScreen);
 }
 
 static void
-xf86RandR12PointerMoved (int scrnIndex, int x, int y)
+xf86RandR12PointerMoved(int scrnIndex, int x, int y)
 {
-    ScreenPtr		pScreen = screenInfo.screens[scrnIndex];
-    ScrnInfoPtr		pScrn   = XF86SCRNINFO(pScreen);
-    xf86CrtcConfigPtr	config  = XF86_CRTC_CONFIG_PTR(pScrn);
-    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
+    ScreenPtr pScreen = screenInfo.screens[scrnIndex];
+    ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
     int c;
 
     randrp->pointerX = x;
     randrp->pointerY = y;
     for (c = 0; c < config->num_crtc; c++)
-	xf86RandR13Pan (config->crtc[c], x, y);
+        xf86RandR13Pan(config->crtc[c], x, y);
 }
 
 static Bool
-xf86RandR13GetPanning (ScreenPtr           pScreen,
-		       RRCrtcPtr           randr_crtc,
-		       BoxPtr              totalArea,
-		       BoxPtr              trackingArea,
-		       INT16               *border)
+xf86RandR13GetPanning(ScreenPtr pScreen,
+                      RRCrtcPtr randr_crtc,
+                      BoxPtr totalArea, BoxPtr trackingArea, INT16 *border)
 {
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
     if (crtc->version < 2)
-	return FALSE;
+        return FALSE;
     if (totalArea)
-	memcpy (totalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
+        memcpy(totalArea, &crtc->panningTotalArea, sizeof(BoxRec));
     if (trackingArea)
-	memcpy (trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
+        memcpy(trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
     if (border)
-	memcpy (border,        crtc->panningBorder,       4*sizeof(INT16));
+        memcpy(border, crtc->panningBorder, 4 * sizeof(INT16));
 
     return TRUE;
 }
 
 static Bool
-xf86RandR13SetPanning (ScreenPtr           pScreen,
-		       RRCrtcPtr           randr_crtc,
-		       BoxPtr              totalArea,
-		       BoxPtr              trackingArea,
-		       INT16               *border)
+xf86RandR13SetPanning(ScreenPtr pScreen,
+                      RRCrtcPtr randr_crtc,
+                      BoxPtr totalArea, BoxPtr trackingArea, INT16 *border)
 {
-    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
-    BoxRec		oldTotalArea;
-    BoxRec		oldTrackingArea;
-    INT16		oldBorder[4];
-
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    BoxRec oldTotalArea;
+    BoxRec oldTrackingArea;
+    INT16 oldBorder[4];
 
     if (crtc->version < 2)
-	return FALSE;
+        return FALSE;
 
-    memcpy (&oldTotalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
-    memcpy (&oldTrackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
-    memcpy (oldBorder,         crtc->panningBorder,       4*sizeof(INT16));
+    memcpy(&oldTotalArea, &crtc->panningTotalArea, sizeof(BoxRec));
+    memcpy(&oldTrackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
+    memcpy(oldBorder, crtc->panningBorder, 4 * sizeof(INT16));
 
     if (totalArea)
-	memcpy (&crtc->panningTotalArea, totalArea, sizeof(BoxRec));
+        memcpy(&crtc->panningTotalArea, totalArea, sizeof(BoxRec));
     if (trackingArea)
-	memcpy (&crtc->panningTrackingArea, trackingArea, sizeof(BoxRec));
+        memcpy(&crtc->panningTrackingArea, trackingArea, sizeof(BoxRec));
     if (border)
-	memcpy (crtc->panningBorder, border, 4*sizeof(INT16));
-
-    if (xf86RandR13VerifyPanningArea (crtc, pScreen->width, pScreen->height)) {
-	xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
-	return TRUE;
-    } else {
-	/* Restore old settings */
-	memcpy (&crtc->panningTotalArea,    &oldTotalArea,    sizeof(BoxRec));
-	memcpy (&crtc->panningTrackingArea, &oldTrackingArea, sizeof(BoxRec));
-	memcpy (crtc->panningBorder,         oldBorder,       4*sizeof(INT16));
-	return FALSE;
+        memcpy(crtc->panningBorder, border, 4 * sizeof(INT16));
+
+    if (xf86RandR13VerifyPanningArea(crtc, pScreen->width, pScreen->height)) {
+        xf86RandR13Pan(crtc, randrp->pointerX, randrp->pointerY);
+        return TRUE;
+    }
+    else {
+        /* Restore old settings */
+        memcpy(&crtc->panningTotalArea, &oldTotalArea, sizeof(BoxRec));
+        memcpy(&crtc->panningTrackingArea, &oldTrackingArea, sizeof(BoxRec));
+        memcpy(crtc->panningBorder, oldBorder, 4 * sizeof(INT16));
+        return FALSE;
     }
 }
 
@@ -1705,11 +1678,12 @@ gamma_to_ramp(float gamma, CARD16 *ramp, int size)
     int i;
 
     for (i = 0; i < size; i++) {
-	if (gamma == 1.0)
-	    ramp[i] = i << 8;
-	else
-	    ramp[i] = (CARD16)(pow((double)i / (double)(size - 1), 1. / gamma)
-			       * (double)(size - 1) * 256);
+        if (gamma == 1.0)
+            ramp[i] = i << 8;
+        else
+            ramp[i] =
+                (CARD16) (pow((double) i / (double) (size - 1), 1. / gamma)
+                          * (double) (size - 1) * 256);
     }
 }
 
@@ -1722,15 +1696,15 @@ xf86RandR12ChangeGamma(int scrnIndex, Gamma gamma)
     int size;
 
     if (!crtc)
-	return Success;
+        return Success;
 
     size = max(0, crtc->gammaSize);
     if (!size)
-	return Success;
+        return Success;
 
     points = calloc(size, 3 * sizeof(CARD16));
     if (!points)
-	return BadAlloc;
+        return BadAlloc;
 
     red = points;
     green = points + size;
@@ -1749,37 +1723,37 @@ xf86RandR12ChangeGamma(int scrnIndex, Gamma gamma)
 }
 
 static Bool
-xf86RandR12EnterVT (int screen_index, int flags)
+xf86RandR12EnterVT(int screen_index, int flags)
 {
-    ScreenPtr        pScreen = screenInfo.screens[screen_index];
-    ScrnInfoPtr	     pScrn = xf86Screens[screen_index];
-    XF86RandRInfoPtr randrp  = XF86RANDRINFO(pScreen);
-    rrScrPrivPtr     rp = rrGetScrPriv(pScreen);
-    Bool	     ret;
-    int              i;
+    ScreenPtr pScreen = screenInfo.screens[screen_index];
+    ScrnInfoPtr pScrn = xf86Screens[screen_index];
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
+    Bool ret;
+    int i;
 
     if (randrp->orig_EnterVT) {
-	pScrn->EnterVT = randrp->orig_EnterVT;
-	ret = pScrn->EnterVT (screen_index, flags);
-	randrp->orig_EnterVT = pScrn->EnterVT;
-	pScrn->EnterVT = xf86RandR12EnterVT;
-	if (!ret)
-	    return FALSE;
+        pScrn->EnterVT = randrp->orig_EnterVT;
+        ret = pScrn->EnterVT(screen_index, flags);
+        randrp->orig_EnterVT = pScrn->EnterVT;
+        pScrn->EnterVT = xf86RandR12EnterVT;
+        if (!ret)
+            return FALSE;
     }
 
     /* reload gamma */
     for (i = 0; i < rp->numCrtcs; i++)
-	xf86RandR12CrtcSetGamma(pScreen, rp->crtcs[i]);
+        xf86RandR12CrtcSetGamma(pScreen, rp->crtcs[i]);
 
-    return RRGetInfo (pScreen, TRUE); /* force a re-probe of outputs and notify clients about changes */
+    return RRGetInfo(pScreen, TRUE);    /* force a re-probe of outputs and notify clients about changes */
 }
 
 static Bool
-xf86RandR12Init12 (ScreenPtr pScreen)
+xf86RandR12Init12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    rrScrPrivPtr	rp = rrGetScrPriv(pScreen);
-    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
     int i;
 
     rp->rrGetInfo = xf86RandR12GetInfo12;
@@ -1802,16 +1776,16 @@ xf86RandR12Init12 (ScreenPtr pScreen)
     randrp->orig_EnterVT = pScrn->EnterVT;
     pScrn->EnterVT = xf86RandR12EnterVT;
 
-    if (!xf86RandR12CreateObjects12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12CreateObjects12(pScreen))
+        return FALSE;
 
     /*
      * Configure output modes
      */
-    if (!xf86RandR12SetInfo12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12SetInfo12(pScreen))
+        return FALSE;
     for (i = 0; i < rp->numCrtcs; i++) {
-	xf86RandR12CrtcGetGamma(pScreen, rp->crtcs[i]);
+        xf86RandR12CrtcGetGamma(pScreen, rp->crtcs[i]);
     }
     return TRUE;
 }
@@ -1819,7 +1793,7 @@ xf86RandR12Init12 (ScreenPtr pScreen)
 #endif
 
 Bool
-xf86RandR12PreInit (ScrnInfoPtr pScrn)
+xf86RandR12PreInit(ScrnInfoPtr pScrn)
 {
     return TRUE;
 }
diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.h b/xorg-server/hw/xfree86/modes/xf86RandR12.h
index 755a472d1..9ad695cec 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.h
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.h
@@ -1,43 +1,46 @@
-/*

- * Copyright © 2006 Keith Packard

- *

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

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

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

- * notice and this permission notice appear in supporting documentation, and

- * that the name of the copyright holders not be used in advertising or

- * publicity pertaining to distribution of the software without specific,

- * written prior permission.  The copyright holders make no representations

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

- * is" without express or implied warranty.

- *

- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR

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

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

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

- * OF THIS SOFTWARE.

- */

-

-#ifndef _XF86_RANDR_H_

-#define _XF86_RANDR_H_

-#include <randrstr.h>

-#include <X11/extensions/render.h>

-#if XF86_MODES_RENAME

-#include "xf86Rename.h"

-#endif

-

-extern _X_EXPORT Bool xf86RandR12CreateScreenResources (ScreenPtr pScreen);

-extern _X_EXPORT Bool xf86RandR12Init(ScreenPtr pScreen);

-extern _X_EXPORT void xf86RandR12CloseScreen(ScreenPtr pScreen);

-extern _X_EXPORT void xf86RandR12SetRotations (ScreenPtr pScreen, Rotation rotation);

-extern _X_EXPORT void xf86RandR12SetTransformSupport (ScreenPtr pScreen, Bool transforms);

-extern _X_EXPORT Bool xf86RandR12SetConfig(ScreenPtr pScreen, Rotation rotation, int rate,

-			RRScreenSizePtr pSize);

-extern _X_EXPORT Rotation xf86RandR12GetRotation(ScreenPtr pScreen);

-extern _X_EXPORT void xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y);

-extern _X_EXPORT Bool xf86RandR12PreInit (ScrnInfoPtr pScrn);

-extern _X_EXPORT void xf86RandR12TellChanged (ScreenPtr pScreen);

-

-#endif /* _XF86_RANDR_H_ */

+/*
+ * Copyright © 2006 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _XF86_RANDR_H_
+#define _XF86_RANDR_H_
+#include <randrstr.h>
+#include <X11/extensions/render.h>
+#if XF86_MODES_RENAME
+#include "xf86Rename.h"
+#endif
+
+extern _X_EXPORT Bool xf86RandR12CreateScreenResources(ScreenPtr pScreen);
+extern _X_EXPORT Bool xf86RandR12Init(ScreenPtr pScreen);
+extern _X_EXPORT void xf86RandR12CloseScreen(ScreenPtr pScreen);
+extern _X_EXPORT void xf86RandR12SetRotations(ScreenPtr pScreen,
+                                              Rotation rotation);
+extern _X_EXPORT void xf86RandR12SetTransformSupport(ScreenPtr pScreen,
+                                                     Bool transforms);
+extern _X_EXPORT Bool xf86RandR12SetConfig(ScreenPtr pScreen, Rotation rotation,
+                                           int rate, RRScreenSizePtr pSize);
+extern _X_EXPORT Rotation xf86RandR12GetRotation(ScreenPtr pScreen);
+extern _X_EXPORT void xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn,
+                                                        int *x, int *y);
+extern _X_EXPORT Bool xf86RandR12PreInit(ScrnInfoPtr pScrn);
+extern _X_EXPORT void xf86RandR12TellChanged(ScreenPtr pScreen);
+
+#endif                          /* _XF86_RANDR_H_ */
diff --git a/xorg-server/hw/xfree86/modes/xf86Rotate.c b/xorg-server/hw/xfree86/modes/xf86Rotate.c
index ff7000b5a..85d75573d 100644
--- a/xorg-server/hw/xfree86/modes/xf86Rotate.c
+++ b/xorg-server/hw/xfree86/modes/xf86Rotate.c
@@ -47,25 +47,25 @@
 /* borrowed from composite extension, move to Render and publish? */
 
 static VisualPtr
-compGetWindowVisual (WindowPtr pWin)
+compGetWindowVisual(WindowPtr pWin)
 {
-    ScreenPtr	    pScreen = pWin->drawable.pScreen;
-    VisualID	    vid = wVisual (pWin);
-    int		    i;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    VisualID vid = wVisual(pWin);
+    int i;
 
     for (i = 0; i < pScreen->numVisuals; i++)
-	if (pScreen->visuals[i].vid == vid)
-	    return &pScreen->visuals[i];
+        if (pScreen->visuals[i].vid == vid)
+            return &pScreen->visuals[i];
     return 0;
 }
 
 static PictFormatPtr
-compWindowFormat (WindowPtr pWin)
+compWindowFormat(WindowPtr pWin)
 {
-    ScreenPtr	pScreen = pWin->drawable.pScreen;
-    
-    return PictureMatchVisual (pScreen, pWin->drawable.depth,
-			       compGetWindowVisual (pWin));
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    return PictureMatchVisual(pScreen, pWin->drawable.depth,
+                              compGetWindowVisual(pWin));
 }
 
 #define F(x)	IntToxFixed(x)
@@ -73,201 +73,190 @@ compWindowFormat (WindowPtr pWin)
 #define toF(x)	((float) (x) / 65536.0f)
 
 static void
-xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
+xf86RotateCrtcRedisplay(xf86CrtcPtr crtc, RegionPtr region)
 {
-    ScrnInfoPtr		scrn = crtc->scrn;
-    ScreenPtr		screen = scrn->pScreen;
-    WindowPtr		root = screen->root;
-    PixmapPtr		dst_pixmap = crtc->rotatedPixmap;
-    PictFormatPtr	format = compWindowFormat (screen->root);
-    int			error;
-    PicturePtr		src, dst;
-    int			n = RegionNumRects(region);
-    BoxPtr		b = RegionRects(region);
-    XID			include_inferiors = IncludeInferiors;
+    ScrnInfoPtr scrn = crtc->scrn;
+    ScreenPtr screen = scrn->pScreen;
+    WindowPtr root = screen->root;
+    PixmapPtr dst_pixmap = crtc->rotatedPixmap;
+    PictFormatPtr format = compWindowFormat(screen->root);
+    int error;
+    PicturePtr src, dst;
+    int n = RegionNumRects(region);
+    BoxPtr b = RegionRects(region);
+    XID include_inferiors = IncludeInferiors;
 
     if (crtc->driverIsPerformingTransform)
-	return;
-
-    src = CreatePicture (None,
-			 &root->drawable,
-			 format,
-			 CPSubwindowMode,
-			 &include_inferiors,
-			 serverClient,
-			 &error);
+        return;
+
+    src = CreatePicture(None,
+                        &root->drawable,
+                        format,
+                        CPSubwindowMode,
+                        &include_inferiors, serverClient, &error);
     if (!src)
-	return;
-
-    dst = CreatePicture (None,
-			 &dst_pixmap->drawable,
-			 format,
-			 0L,
-			 NULL,
-			 serverClient,
-			 &error);
+        return;
+
+    dst = CreatePicture(None,
+                        &dst_pixmap->drawable,
+                        format, 0L, NULL, serverClient, &error);
     if (!dst)
-	return;
+        return;
 
-    error = SetPictureTransform (src, &crtc->crtc_to_framebuffer);
+    error = SetPictureTransform(src, &crtc->crtc_to_framebuffer);
     if (error)
-	return;
+        return;
     if (crtc->transform_in_use && crtc->filter)
-	SetPicturePictFilter (src, crtc->filter,
-			      crtc->params, crtc->nparams);
-
-    if (crtc->shadowClear)
-    {
-	CompositePicture (PictOpSrc,
-			  src, NULL, dst,
-			  0, 0, 0, 0, 0, 0,
-			  crtc->mode.HDisplay, crtc->mode.VDisplay);
-	crtc->shadowClear = FALSE;
+        SetPicturePictFilter(src, crtc->filter, crtc->params, crtc->nparams);
+
+    if (crtc->shadowClear) {
+        CompositePicture(PictOpSrc,
+                         src, NULL, dst,
+                         0, 0, 0, 0, 0, 0,
+                         crtc->mode.HDisplay, crtc->mode.VDisplay);
+        crtc->shadowClear = FALSE;
     }
-    else
-    {
-	while (n--)
-	{
-	    BoxRec	dst_box;
-
-	    dst_box = *b;
-	    dst_box.x1 -= crtc->filter_width >> 1;
-	    dst_box.x2 += crtc->filter_width >> 1;
-	    dst_box.y1 -= crtc->filter_height >> 1;
-	    dst_box.y2 += crtc->filter_height >> 1;
-	    pixman_f_transform_bounds (&crtc->f_framebuffer_to_crtc, &dst_box);
-	    CompositePicture (PictOpSrc,
-			      src, NULL, dst,
-			      dst_box.x1, dst_box.y1, 0, 0, dst_box.x1, dst_box.y1,
-			      dst_box.x2 - dst_box.x1,
-			      dst_box.y2 - dst_box.y1);
-	    b++;
-	}
+    else {
+        while (n--) {
+            BoxRec dst_box;
+
+            dst_box = *b;
+            dst_box.x1 -= crtc->filter_width >> 1;
+            dst_box.x2 += crtc->filter_width >> 1;
+            dst_box.y1 -= crtc->filter_height >> 1;
+            dst_box.y2 += crtc->filter_height >> 1;
+            pixman_f_transform_bounds(&crtc->f_framebuffer_to_crtc, &dst_box);
+            CompositePicture(PictOpSrc,
+                             src, NULL, dst,
+                             dst_box.x1, dst_box.y1, 0, 0, dst_box.x1,
+                             dst_box.y1, dst_box.x2 - dst_box.x1,
+                             dst_box.y2 - dst_box.y1);
+            b++;
+        }
     }
-    FreePicture (src, None);
-    FreePicture (dst, None);
+    FreePicture(src, None);
+    FreePicture(dst, None);
 }
 
 static void
-xf86CrtcDamageShadow (xf86CrtcPtr crtc)
+xf86CrtcDamageShadow(xf86CrtcPtr crtc)
 {
-    ScrnInfoPtr	pScrn = crtc->scrn;
-    BoxRec	damage_box;
-    RegionRec   damage_region;
-    ScreenPtr	pScreen = pScrn->pScreen;
+    ScrnInfoPtr pScrn = crtc->scrn;
+    BoxRec damage_box;
+    RegionRec damage_region;
+    ScreenPtr pScreen = pScrn->pScreen;
 
     damage_box.x1 = 0;
     damage_box.x2 = crtc->mode.HDisplay;
     damage_box.y1 = 0;
     damage_box.y2 = crtc->mode.VDisplay;
-    if (!pixman_transform_bounds (&crtc->crtc_to_framebuffer, &damage_box))
-    {
-	damage_box.x1 = 0;
-	damage_box.y1 = 0;
-	damage_box.x2 = pScreen->width;
-	damage_box.y2 = pScreen->height;
+    if (!pixman_transform_bounds(&crtc->crtc_to_framebuffer, &damage_box)) {
+        damage_box.x1 = 0;
+        damage_box.y1 = 0;
+        damage_box.x2 = pScreen->width;
+        damage_box.y2 = pScreen->height;
     }
-    if (damage_box.x1 < 0) damage_box.x1 = 0;
-    if (damage_box.y1 < 0) damage_box.y1 = 0;
-    if (damage_box.x2 > pScreen->width) damage_box.x2 = pScreen->width;
-    if (damage_box.y2 > pScreen->height) damage_box.y2 = pScreen->height;
+    if (damage_box.x1 < 0)
+        damage_box.x1 = 0;
+    if (damage_box.y1 < 0)
+        damage_box.y1 = 0;
+    if (damage_box.x2 > pScreen->width)
+        damage_box.x2 = pScreen->width;
+    if (damage_box.y2 > pScreen->height)
+        damage_box.y2 = pScreen->height;
     RegionInit(&damage_region, &damage_box, 1);
-    DamageDamageRegion (&(*pScreen->GetScreenPixmap)(pScreen)->drawable,
-			&damage_region);
+    DamageDamageRegion(&(*pScreen->GetScreenPixmap) (pScreen)->drawable,
+                       &damage_region);
     RegionUninit(&damage_region);
     crtc->shadowClear = TRUE;
 }
 
 static void
-xf86RotatePrepare (ScreenPtr pScreen)
+xf86RotatePrepare(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
 
-    for (c = 0; c < xf86_config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = xf86_config->crtc[c];
-	
-	if (crtc->rotatedData && !crtc->rotatedPixmap)
-	{
-	    crtc->rotatedPixmap = crtc->funcs->shadow_create (crtc,
-							     crtc->rotatedData,
-							     crtc->mode.HDisplay,
-							     crtc->mode.VDisplay);
-	    if (!xf86_config->rotation_damage_registered)
-	    {
-		/* Hook damage to screen pixmap */
-		DamageRegister (&pScreen->root->drawable,
-				xf86_config->rotation_damage);
-		xf86_config->rotation_damage_registered = TRUE;
-		EnableLimitedSchedulingLatency();
-	    }
-	    
-	    xf86CrtcDamageShadow (crtc);
-	}
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+        if (crtc->rotatedData && !crtc->rotatedPixmap) {
+            crtc->rotatedPixmap = crtc->funcs->shadow_create(crtc,
+                                                             crtc->rotatedData,
+                                                             crtc->mode.
+                                                             HDisplay,
+                                                             crtc->mode.
+                                                             VDisplay);
+            if (!xf86_config->rotation_damage_registered) {
+                /* Hook damage to screen pixmap */
+                DamageRegister(&pScreen->root->drawable,
+                               xf86_config->rotation_damage);
+                xf86_config->rotation_damage_registered = TRUE;
+                EnableLimitedSchedulingLatency();
+            }
+
+            xf86CrtcDamageShadow(crtc);
+        }
     }
 }
 
 static Bool
 xf86RotateRedisplay(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    DamagePtr		damage = xf86_config->rotation_damage;
-    RegionPtr		region;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    DamagePtr damage = xf86_config->rotation_damage;
+    RegionPtr region;
 
     if (!damage)
-	return FALSE;
-    xf86RotatePrepare (pScreen);
+        return FALSE;
+    xf86RotatePrepare(pScreen);
     region = DamageRegion(damage);
-    if (RegionNotEmpty(region))
-    {
-	int			c;
-	SourceValidateProcPtr	SourceValidate;
-
-	/*
-	 * SourceValidate is used by the software cursor code
-	 * to pull the cursor off of the screen when reading
-	 * bits from the frame buffer. Bypassing this function
-	 * leaves the software cursor in place
-	 */
-	SourceValidate = pScreen->SourceValidate;
-	pScreen->SourceValidate = NULL;
-
-	for (c = 0; c < xf86_config->num_crtc; c++)
-	{
-	    xf86CrtcPtr	    crtc = xf86_config->crtc[c];
-
-	    if (crtc->transform_in_use && crtc->enabled)
-	    {
-		RegionRec   crtc_damage;
-
-		/* compute portion of damage that overlaps crtc */
-		RegionInit(&crtc_damage, &crtc->bounds, 1);
-		RegionIntersect(&crtc_damage, &crtc_damage, region);
-		
-		/* update damaged region */
-		if (RegionNotEmpty(&crtc_damage))
-    		    xf86RotateCrtcRedisplay (crtc, &crtc_damage);
-		
-		RegionUninit(&crtc_damage);
-	    }
-	}
-	pScreen->SourceValidate = SourceValidate;
-	DamageEmpty(damage);
+    if (RegionNotEmpty(region)) {
+        int c;
+        SourceValidateProcPtr SourceValidate;
+
+        /*
+         * SourceValidate is used by the software cursor code
+         * to pull the cursor off of the screen when reading
+         * bits from the frame buffer. Bypassing this function
+         * leaves the software cursor in place
+         */
+        SourceValidate = pScreen->SourceValidate;
+        pScreen->SourceValidate = NULL;
+
+        for (c = 0; c < xf86_config->num_crtc; c++) {
+            xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+            if (crtc->transform_in_use && crtc->enabled) {
+                RegionRec crtc_damage;
+
+                /* compute portion of damage that overlaps crtc */
+                RegionInit(&crtc_damage, &crtc->bounds, 1);
+                RegionIntersect(&crtc_damage, &crtc_damage, region);
+
+                /* update damaged region */
+                if (RegionNotEmpty(&crtc_damage))
+                    xf86RotateCrtcRedisplay(crtc, &crtc_damage);
+
+                RegionUninit(&crtc_damage);
+            }
+        }
+        pScreen->SourceValidate = SourceValidate;
+        DamageEmpty(damage);
     }
     return TRUE;
 }
 
 static void
 xf86RotateBlockHandler(int screenNum, pointer blockData,
-		       pointer pTimeout, pointer pReadmask)
+                       pointer pTimeout, pointer pReadmask)
 {
-    ScreenPtr		pScreen = screenInfo.screens[screenNum];
-    ScrnInfoPtr		pScrn = xf86Screens[screenNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    Bool		rotation_active;
+    ScreenPtr pScreen = screenInfo.screens[screenNum];
+    ScrnInfoPtr pScrn = xf86Screens[screenNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    Bool rotation_active;
 
     rotation_active = xf86RotateRedisplay(pScreen);
     pScreen->BlockHandler = xf86_config->BlockHandler;
@@ -278,40 +267,38 @@ xf86RotateBlockHandler(int screenNum, pointer blockData,
 }
 
 void
-xf86RotateDestroy (xf86CrtcPtr crtc)
+xf86RotateDestroy(xf86CrtcPtr crtc)
 {
-    ScrnInfoPtr		pScrn = crtc->scrn;
-    ScreenPtr		pScreen = pScrn->pScreen;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
-    
+    ScrnInfoPtr pScrn = crtc->scrn;
+    ScreenPtr pScreen = pScrn->pScreen;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+
     /* Free memory from rotation */
-    if (crtc->rotatedPixmap || crtc->rotatedData)
-    {
-	crtc->funcs->shadow_destroy (crtc, crtc->rotatedPixmap, crtc->rotatedData);
-	crtc->rotatedPixmap = NULL;
-	crtc->rotatedData = NULL;
+    if (crtc->rotatedPixmap || crtc->rotatedData) {
+        crtc->funcs->shadow_destroy(crtc, crtc->rotatedPixmap,
+                                    crtc->rotatedData);
+        crtc->rotatedPixmap = NULL;
+        crtc->rotatedData = NULL;
     }
 
     for (c = 0; c < xf86_config->num_crtc; c++)
-	if (xf86_config->crtc[c]->rotatedData)
-	    return;
+        if (xf86_config->crtc[c]->rotatedData)
+            return;
 
     /*
      * Clean up damage structures when no crtcs are rotated
      */
-    if (xf86_config->rotation_damage)
-    {
-	/* Free damage structure */
-	if (xf86_config->rotation_damage_registered)
-	{
-	    DamageUnregister (&pScreen->root->drawable,
-			      xf86_config->rotation_damage);
-	    xf86_config->rotation_damage_registered = FALSE;
-	    DisableLimitedSchedulingLatency();
-	}
-	DamageDestroy (xf86_config->rotation_damage);
-	xf86_config->rotation_damage = NULL;
+    if (xf86_config->rotation_damage) {
+        /* Free damage structure */
+        if (xf86_config->rotation_damage_registered) {
+            DamageUnregister(&pScreen->root->drawable,
+                             xf86_config->rotation_damage);
+            xf86_config->rotation_damage_registered = FALSE;
+            DisableLimitedSchedulingLatency();
+        }
+        DamageDestroy(xf86_config->rotation_damage);
+        xf86_config->rotation_damage = NULL;
     }
 }
 
@@ -321,193 +308,186 @@ xf86RotateFreeShadow(ScrnInfoPtr pScrn)
     xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
     int c;
 
-   for (c = 0; c < config->num_crtc; c++) {
-       xf86CrtcPtr crtc = config->crtc[c];
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
 
-       if (crtc->rotatedPixmap || crtc->rotatedData) {
-	   crtc->funcs->shadow_destroy(crtc, crtc->rotatedPixmap,
-				crtc->rotatedData);
-	   crtc->rotatedPixmap = NULL;
-	   crtc->rotatedData = NULL;
-       }
-   }
+        if (crtc->rotatedPixmap || crtc->rotatedData) {
+            crtc->funcs->shadow_destroy(crtc, crtc->rotatedPixmap,
+                                        crtc->rotatedData);
+            crtc->rotatedPixmap = NULL;
+            crtc->rotatedData = NULL;
+        }
+    }
 }
 
 void
-xf86RotateCloseScreen (ScreenPtr screen)
+xf86RotateCloseScreen(ScreenPtr screen)
 {
-    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-    int			c;
+    ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int c;
 
     for (c = 0; c < xf86_config->num_crtc; c++)
-	xf86RotateDestroy (xf86_config->crtc[c]);
+        xf86RotateDestroy(xf86_config->crtc[c]);
 }
 
 static Bool
-xf86CrtcFitsScreen (xf86CrtcPtr crtc, struct pict_f_transform *crtc_to_fb)
+xf86CrtcFitsScreen(xf86CrtcPtr crtc, struct pict_f_transform *crtc_to_fb)
 {
-    ScrnInfoPtr		pScrn = crtc->scrn;
-    BoxRec		b;
+    ScrnInfoPtr pScrn = crtc->scrn;
+    BoxRec b;
 
     /* When called before PreInit, the driver is
      * presumably doing load detect
      */
     if (pScrn->virtualX == 0 || pScrn->virtualY == 0)
-	return TRUE;
+        return TRUE;
 
     b.x1 = 0;
     b.y1 = 0;
     b.x2 = crtc->mode.HDisplay;
     b.y2 = crtc->mode.VDisplay;
     if (crtc_to_fb)
-	pixman_f_transform_bounds (crtc_to_fb, &b);
+        pixman_f_transform_bounds(crtc_to_fb, &b);
     else {
-	b.x1 += crtc->x;
-	b.y1 += crtc->y;
-	b.x2 += crtc->x;
-	b.y2 += crtc->y;
+        b.x1 += crtc->x;
+        b.y1 += crtc->y;
+        b.x2 += crtc->x;
+        b.y2 += crtc->y;
     }
 
     return (0 <= b.x1 && b.x2 <= pScrn->virtualX &&
-	    0 <= b.y1 && b.y2 <= pScrn->virtualY);
+            0 <= b.y1 && b.y2 <= pScrn->virtualY);
 }
 
 Bool
-xf86CrtcRotate (xf86CrtcPtr crtc)
+xf86CrtcRotate(xf86CrtcPtr crtc)
 {
-    ScrnInfoPtr		pScrn = crtc->scrn;
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    ScrnInfoPtr pScrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+
     /* if this is called during ScreenInit() we don't have pScrn->pScreen yet */
-    ScreenPtr		pScreen = screenInfo.screens[pScrn->scrnIndex];
-    PictTransform	crtc_to_fb;
+    ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
+    PictTransform crtc_to_fb;
     struct pict_f_transform f_crtc_to_fb, f_fb_to_crtc;
-    xFixed		*new_params = NULL;
-    int			new_nparams = 0;
-    PictFilterPtr	new_filter = NULL;
-    int			new_width = 0;
-    int			new_height = 0;
-    RRTransformPtr	transform = NULL;
-    Bool		damage = FALSE;
+    xFixed *new_params = NULL;
+    int new_nparams = 0;
+    PictFilterPtr new_filter = NULL;
+    int new_width = 0;
+    int new_height = 0;
+    RRTransformPtr transform = NULL;
+    Bool damage = FALSE;
 
     if (crtc->transformPresent)
-	transform = &crtc->transform;
-
-    if (!RRTransformCompute (crtc->x, crtc->y,
-			     crtc->mode.HDisplay, crtc->mode.VDisplay,
-			     crtc->rotation,
-			     transform,
-
-			     &crtc_to_fb,
-			     &f_crtc_to_fb,
-			     &f_fb_to_crtc) &&
-	xf86CrtcFitsScreen (crtc, &f_crtc_to_fb))
-    {
-	/*
-	 * If the untranslated transformation is the identity,
-	 * disable the shadow buffer
-	 */
-	xf86RotateDestroy (crtc);
-	crtc->transform_in_use = FALSE;
-	free(new_params);
-	new_params = NULL;
-	new_nparams = 0;
-	new_filter = NULL;
-	new_width = 0;
-	new_height = 0;
+        transform = &crtc->transform;
+
+    if (!RRTransformCompute(crtc->x, crtc->y,
+                            crtc->mode.HDisplay, crtc->mode.VDisplay,
+                            crtc->rotation,
+                            transform,
+                            &crtc_to_fb,
+                            &f_crtc_to_fb,
+                            &f_fb_to_crtc) &&
+        xf86CrtcFitsScreen(crtc, &f_crtc_to_fb)) {
+        /*
+         * If the untranslated transformation is the identity,
+         * disable the shadow buffer
+         */
+        xf86RotateDestroy(crtc);
+        crtc->transform_in_use = FALSE;
+        free(new_params);
+        new_params = NULL;
+        new_nparams = 0;
+        new_filter = NULL;
+        new_width = 0;
+        new_height = 0;
     }
-    else
-    {
-	if (crtc->driverIsPerformingTransform) {
-	    xf86RotateDestroy(crtc);
-	} else {
-	    /*
-	     * these are the size of the shadow pixmap, which
-	     * matches the mode, not the pre-rotated copy in the
-	     * frame buffer
-	     */
-	    int		width = crtc->mode.HDisplay;
-	    int		height = crtc->mode.VDisplay;
-	    void	*shadowData = crtc->rotatedData;
-	    PixmapPtr	shadow = crtc->rotatedPixmap;
-	    int		old_width = shadow ? shadow->drawable.width : 0;
-	    int		old_height = shadow ? shadow->drawable.height : 0;
-
-	    /* Allocate memory for rotation */
-	    if (old_width != width || old_height != height)
-	    {
-		if (shadow || shadowData)
-		{
-		    crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
-		    crtc->rotatedPixmap = NULL;
-		    crtc->rotatedData = NULL;
-		}
-		shadowData = crtc->funcs->shadow_allocate (crtc, width, height);
-		if (!shadowData)
-		    goto bail1;
-		crtc->rotatedData = shadowData;
-		/* shadow will be damaged in xf86RotatePrepare */
-	    }
-	    else
-	    {
-		/* mark shadowed area as damaged so it will be repainted */
-		damage = TRUE;
-	    }
-
-	    if (!xf86_config->rotation_damage)
-	    {
-		/* Create damage structure */
-		xf86_config->rotation_damage = DamageCreate (NULL, NULL,
-						    DamageReportNone,
-						    TRUE, pScreen, pScreen);
-		if (!xf86_config->rotation_damage)
-		    goto bail2;
-
-		/* Wrap block handler */
-		if (!xf86_config->BlockHandler) {
-		    xf86_config->BlockHandler = pScreen->BlockHandler;
-		    pScreen->BlockHandler = xf86RotateBlockHandler;
-		}
-	    }
-
-	    if (0)
-	    {
-	bail2:
-		if (shadow || shadowData)
-		{
-		    crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
-		    crtc->rotatedPixmap = NULL;
-		    crtc->rotatedData = NULL;
-		}
-	bail1:
-		if (old_width && old_height)
-		    crtc->rotatedPixmap =
-			crtc->funcs->shadow_create (crtc, NULL, old_width,
-						    old_height);
-		return FALSE;
-	    }
-	}
+    else {
+        if (crtc->driverIsPerformingTransform) {
+            xf86RotateDestroy(crtc);
+        }
+        else {
+            /*
+             * these are the size of the shadow pixmap, which
+             * matches the mode, not the pre-rotated copy in the
+             * frame buffer
+             */
+            int width = crtc->mode.HDisplay;
+            int height = crtc->mode.VDisplay;
+            void *shadowData = crtc->rotatedData;
+            PixmapPtr shadow = crtc->rotatedPixmap;
+            int old_width = shadow ? shadow->drawable.width : 0;
+            int old_height = shadow ? shadow->drawable.height : 0;
+
+            /* Allocate memory for rotation */
+            if (old_width != width || old_height != height) {
+                if (shadow || shadowData) {
+                    crtc->funcs->shadow_destroy(crtc, shadow, shadowData);
+                    crtc->rotatedPixmap = NULL;
+                    crtc->rotatedData = NULL;
+                }
+                shadowData = crtc->funcs->shadow_allocate(crtc, width, height);
+                if (!shadowData)
+                    goto bail1;
+                crtc->rotatedData = shadowData;
+                /* shadow will be damaged in xf86RotatePrepare */
+            }
+            else {
+                /* mark shadowed area as damaged so it will be repainted */
+                damage = TRUE;
+            }
+
+            if (!xf86_config->rotation_damage) {
+                /* Create damage structure */
+                xf86_config->rotation_damage = DamageCreate(NULL, NULL,
+                                                            DamageReportNone,
+                                                            TRUE, pScreen,
+                                                            pScreen);
+                if (!xf86_config->rotation_damage)
+                    goto bail2;
+
+                /* Wrap block handler */
+                if (!xf86_config->BlockHandler) {
+                    xf86_config->BlockHandler = pScreen->BlockHandler;
+                    pScreen->BlockHandler = xf86RotateBlockHandler;
+                }
+            }
+
+            if (0) {
+ bail2:
+                if (shadow || shadowData) {
+                    crtc->funcs->shadow_destroy(crtc, shadow, shadowData);
+                    crtc->rotatedPixmap = NULL;
+                    crtc->rotatedData = NULL;
+                }
+ bail1:
+                if (old_width && old_height)
+                    crtc->rotatedPixmap =
+                        crtc->funcs->shadow_create(crtc, NULL, old_width,
+                                                   old_height);
+                return FALSE;
+            }
+        }
 #ifdef RANDR_12_INTERFACE
-	if (transform)
-	{
-	    if (transform->nparams) {
-		new_params = malloc(transform->nparams * sizeof (xFixed));
-		if (new_params) {
-		    memcpy (new_params, transform->params,
-			    transform->nparams * sizeof (xFixed));
-		    new_nparams = transform->nparams;
-		    new_filter = transform->filter;
-		}
-	    } else
-		new_filter = transform->filter;
-	    if (new_filter)
-	    {
-		new_width = new_filter->width;
-		new_height = new_filter->height;
-	    }
-	}
+        if (transform) {
+            if (transform->nparams) {
+                new_params = malloc(transform->nparams * sizeof(xFixed));
+                if (new_params) {
+                    memcpy(new_params, transform->params,
+                           transform->nparams * sizeof(xFixed));
+                    new_nparams = transform->nparams;
+                    new_filter = transform->filter;
+                }
+            }
+            else
+                new_filter = transform->filter;
+            if (new_filter) {
+                new_width = new_filter->width;
+                new_height = new_filter->height;
+            }
+        }
 #endif
-	crtc->transform_in_use = TRUE;
+        crtc->transform_in_use = TRUE;
     }
     crtc->crtc_to_framebuffer = crtc_to_fb;
     crtc->f_crtc_to_framebuffer = f_crtc_to_fb;
@@ -522,10 +502,10 @@ xf86CrtcRotate (xf86CrtcPtr crtc)
     crtc->bounds.x2 = crtc->mode.HDisplay;
     crtc->bounds.y1 = 0;
     crtc->bounds.y2 = crtc->mode.VDisplay;
-    pixman_f_transform_bounds (&f_crtc_to_fb, &crtc->bounds);
+    pixman_f_transform_bounds(&f_crtc_to_fb, &crtc->bounds);
 
     if (damage)
-        xf86CrtcDamageShadow (crtc);
+        xf86CrtcDamageShadow(crtc);
 
     /* All done */
     return TRUE;
diff --git a/xorg-server/hw/xfree86/modes/xf86cvt.c b/xorg-server/hw/xfree86/modes/xf86cvt.c
index d5fecccb5..de0784493 100644
--- a/xorg-server/hw/xfree86/modes/xf86cvt.c
+++ b/xorg-server/hw/xfree86/modes/xf86cvt.c
@@ -65,12 +65,12 @@
  */
 DisplayModePtr
 xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
-	    Bool Interlaced)
+            Bool Interlaced)
 {
-    DisplayModeRec  *Mode = xnfcalloc(1, sizeof(DisplayModeRec));
+    DisplayModeRec *Mode = xnfcalloc(1, sizeof(DisplayModeRec));
 
     /* 1) top/bottom margin size (% of height) - default: 1.8 */
-#define CVT_MARGIN_PERCENTAGE 1.8    
+#define CVT_MARGIN_PERCENTAGE 1.8
 
     /* 2) character cell horizontal granularity (pixels) - default 8 */
 #define CVT_H_GRANULARITY 8
@@ -85,10 +85,10 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
 #define CVT_CLOCK_STEP 250
 
     Bool Margins = FALSE;
-    float  VFieldRate, HPeriod;
-    int  HDisplayRnd, HMargin;
-    int  VDisplayRnd, VMargin, VSync;
-    float  Interlace; /* Please rename this */
+    float VFieldRate, HPeriod;
+    int HDisplayRnd, HMargin;
+    int VDisplayRnd, VMargin, VSync;
+    float Interlace;            /* Please rename this */
 
     /* CVT default is 60.0Hz */
     if (!VRefresh)
@@ -108,11 +108,12 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         /* right margin is actually exactly the same as left */
         HMargin = (((float) HDisplayRnd) * CVT_MARGIN_PERCENTAGE / 100.0);
         HMargin -= HMargin % CVT_H_GRANULARITY;
-    } else
+    }
+    else
         HMargin = 0;
 
     /* 4. Find total active pixels */
-    Mode->HDisplay = HDisplayRnd + 2*HMargin;
+    Mode->HDisplay = HDisplayRnd + 2 * HMargin;
 
     /* 5. Find number of lines per field */
     if (Interlaced)
@@ -128,7 +129,7 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
     else
         VMargin = 0;
 
-    Mode->VDisplay = VDisplay + 2*VMargin;
+    Mode->VDisplay = VDisplay + 2 * VMargin;
 
     /* 7. Interlace */
     if (Interlaced)
@@ -147,10 +148,10 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         VSync = 7;
     else if (!(VDisplay % 9) && ((VDisplay * 15 / 9) == HDisplay))
         VSync = 7;
-    else /* Custom */
+    else                        /* Custom */
         VSync = 10;
 
-    if (!Reduced) { /* simplified GTF calculation */
+    if (!Reduced) {             /* simplified GTF calculation */
 
         /* 4) Minimum time of vertical sync + back porch interval (µs) 
          * default 550.0 */
@@ -159,19 +160,20 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         /* 3) Nominal HSync width (% of line period) - default 8 */
 #define CVT_HSYNC_PERCENTAGE 8
 
-        float  HBlankPercentage;
-        int  VSyncAndBackPorch, VBackPorch;
-        int  HBlank;
+        float HBlankPercentage;
+        int VSyncAndBackPorch, VBackPorch;
+        int HBlank;
 
         /* 8. Estimated Horizontal period */
-        HPeriod = ((float) (1000000.0 / VFieldRate - CVT_MIN_VSYNC_BP)) / 
+        HPeriod = ((float) (1000000.0 / VFieldRate - CVT_MIN_VSYNC_BP)) /
             (VDisplayRnd + 2 * VMargin + CVT_MIN_V_PORCH + Interlace);
 
         /* 9. Find number of lines in sync + backporch */
-        if (((int)(CVT_MIN_VSYNC_BP / HPeriod) + 1) < (VSync + CVT_MIN_V_PORCH))
+        if (((int) (CVT_MIN_VSYNC_BP / HPeriod) + 1) <
+            (VSync + CVT_MIN_V_PORCH))
             VSyncAndBackPorch = VSync + CVT_MIN_V_PORCH;
         else
-            VSyncAndBackPorch = (int)(CVT_MIN_VSYNC_BP / HPeriod) + 1;
+            VSyncAndBackPorch = (int) (CVT_MIN_VSYNC_BP / HPeriod) + 1;
 
         /* 10. Find number of lines in back porch */
         VBackPorch = VSyncAndBackPorch - VSync;
@@ -198,31 +200,32 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         CVT_J_FACTOR
 
         /* 12. Find ideal blanking duty cycle from formula */
-        HBlankPercentage = CVT_C_PRIME - CVT_M_PRIME * HPeriod/1000.0;
+        HBlankPercentage = CVT_C_PRIME - CVT_M_PRIME * HPeriod / 1000.0;
 
         /* 13. Blanking time */
         if (HBlankPercentage < 20)
             HBlankPercentage = 20;
 
-        HBlank = Mode->HDisplay * HBlankPercentage/(100.0 - HBlankPercentage);
-        HBlank -= HBlank % (2*CVT_H_GRANULARITY);
-        
+        HBlank = Mode->HDisplay * HBlankPercentage / (100.0 - HBlankPercentage);
+        HBlank -= HBlank % (2 * CVT_H_GRANULARITY);
+
         /* 14. Find total number of pixels in a line. */
         Mode->HTotal = Mode->HDisplay + HBlank;
 
         /* Fill in HSync values */
         Mode->HSyncEnd = Mode->HDisplay + HBlank / 2;
 
-        Mode->HSyncStart = Mode->HSyncEnd - 
+        Mode->HSyncStart = Mode->HSyncEnd -
             (Mode->HTotal * CVT_HSYNC_PERCENTAGE) / 100;
-        Mode->HSyncStart += CVT_H_GRANULARITY - 
+        Mode->HSyncStart += CVT_H_GRANULARITY -
             Mode->HSyncStart % CVT_H_GRANULARITY;
 
         /* Fill in VSync values */
         Mode->VSyncStart = Mode->VDisplay + CVT_MIN_V_PORCH;
         Mode->VSyncEnd = Mode->VSyncStart + VSync;
 
-    } else { /* Reduced blanking */
+    }
+    else {                      /* Reduced blanking */
         /* Minimum vertical blanking interval time (µs) - default 460 */
 #define CVT_RB_MIN_VBLANK 460.0
 
@@ -235,11 +238,11 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         /* Fixed number of lines for vertical front porch - default 3 */
 #define CVT_RB_VFPORCH 3
 
-        int  VBILines;
+        int VBILines;
 
         /* 8. Estimate Horizontal period. */
-        HPeriod = ((float) (1000000.0 / VFieldRate - CVT_RB_MIN_VBLANK)) / 
-            (VDisplayRnd + 2*VMargin);
+        HPeriod = ((float) (1000000.0 / VFieldRate - CVT_RB_MIN_VBLANK)) /
+            (VDisplayRnd + 2 * VMargin);
 
         /* 9. Find number of lines in vertical blanking */
         VBILines = ((float) CVT_RB_MIN_VBLANK) / HPeriod + 1;
@@ -247,7 +250,7 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
         /* 10. Check if vertical blanking is sufficient */
         if (VBILines < (CVT_RB_VFPORCH + VSync + CVT_MIN_V_BPORCH))
             VBILines = CVT_RB_VFPORCH + VSync + CVT_MIN_V_BPORCH;
-        
+
         /* 11. Find total number of lines in vertical field */
         Mode->VTotal = VDisplayRnd + 2 * VMargin + Interlace + VBILines;
 
@@ -271,7 +274,7 @@ xf86CVTMode(int HDisplay, int VDisplay, float VRefresh, Bool Reduced,
     Mode->HSync = ((float) Mode->Clock) / ((float) Mode->HTotal);
 
     /* 17/15. Find actual Field rate */
-    Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) / 
+    Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) /
         ((float) (Mode->HTotal * Mode->VTotal));
 
     /* 18/16. Find actual vertical frame frequency */
diff --git a/xorg-server/hw/xfree86/modes/xf86gtf.c b/xorg-server/hw/xfree86/modes/xf86gtf.c
index 9d5d50a2d..23707b481 100644
--- a/xorg-server/hw/xfree86/modes/xf86gtf.c
+++ b/xorg-server/hw/xfree86/modes/xf86gtf.c
@@ -61,7 +61,7 @@
 /* Ruthlessly converted to server code by Adam Jackson <ajax@redhat.com> */
 
 #ifdef HAVE_XORG_CONFIG_H
-# include <xorg-config.h>
+#include <xorg-config.h>
 #else
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -88,7 +88,6 @@
 #define C_PRIME           (((C - J) * K/256.0) + J)
 #define M_PRIME           (K/256.0 * M)
 
-
 /*
  * xf86GTFMode() - as defined by the GTF Timing Standard, compute the
  * Stage 1 Parameters using the vertical refresh frequency.  In other
@@ -141,9 +140,9 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *
      *  [H PIXELS RND] = ((ROUND([H PIXELS]/[CELL GRAN RND],0))*[CELLGRAN RND])
      */
-    
+
     h_pixels_rnd = rint((float) h_pixels / CELL_GRAN) * CELL_GRAN;
-    
+
     /*  2. If interlace is requested, the number of vertical lines assumed
      *  by the calculation must be halved, as the computation calculates
      *  the number of vertical lines per field. In either case, the
@@ -154,9 +153,8 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      */
 
     v_lines_rnd = interlaced ?
-            rint((float) v_lines) / 2.0 :
-            rint((float) v_lines);
-    
+        rint((float) v_lines) / 2.0 : rint((float) v_lines);
+
     /*  3. Find the frame rate required:
      *
      *  [V FIELD RATE RQD] = IF([INT RQD?]="y", [I/P FREQ RQD]*2,
@@ -181,7 +179,8 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *          0)
      */
 
-    bottom_margin = margins ? rint(MARGIN_PERCENT/100.0 * v_lines_rnd) : (0.0);
+    bottom_margin =
+        margins ? rint(MARGIN_PERCENT / 100.0 * v_lines_rnd) : (0.0);
 
     /*  6. If interlace is required, then set variable [INTERLACE]=0.5:
      *   
@@ -197,8 +196,8 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *                     [MIN PORCH RND]+[INTERLACE]) * 1000000
      */
 
-    h_period_est = (((1.0/v_field_rate_rqd) - (MIN_VSYNC_PLUS_BP/1000000.0))
-                    / (v_lines_rnd + (2*top_margin) + MIN_PORCH + interlace)
+    h_period_est = (((1.0 / v_field_rate_rqd) - (MIN_VSYNC_PLUS_BP / 1000000.0))
+                    / (v_lines_rnd + (2 * top_margin) + MIN_PORCH + interlace)
                     * 1000000.0);
 
     /*  8. Find the number of lines in V sync + back porch:
@@ -206,7 +205,7 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *  [V SYNC+BP] = ROUND(([MIN VSYNC+BP]/[H PERIOD EST]),0)
      */
 
-    vsync_plus_bp = rint(MIN_VSYNC_PLUS_BP/h_period_est);
+    vsync_plus_bp = rint(MIN_VSYNC_PLUS_BP / h_period_est);
 
     /*  9. Find the number of lines in V back porch alone:
      *
@@ -214,9 +213,9 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *
      *  XXX is "[V SYNC RND]" a typo? should be [V SYNC RQD]?
      */
-    
+
     v_back_porch = vsync_plus_bp - V_SYNC_RQD;
-    
+
     /*  10. Find the total number of lines in Vertical field period:
      *
      *  [TOTAL V LINES] = [V LINES RND] + [TOP MARGIN (LINES)] +
@@ -226,21 +225,21 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
 
     total_v_lines = v_lines_rnd + top_margin + bottom_margin + vsync_plus_bp +
         interlace + MIN_PORCH;
-    
+
     /*  11. Estimate the Vertical field frequency:
      *
      *  [V FIELD RATE EST] = 1 / [H PERIOD EST] / [TOTAL V LINES] * 1000000
      */
 
     v_field_rate_est = 1.0 / h_period_est / total_v_lines * 1000000.0;
-    
+
     /*  12. Find the actual horizontal period:
      *
      *  [H PERIOD] = [H PERIOD EST] / ([V FIELD RATE RQD] / [V FIELD RATE EST])
      */
 
     h_period = h_period_est / (v_field_rate_rqd / v_field_rate_est);
-    
+
     /*  13. Find the actual Vertical field frequency:
      *
      *  [V FIELD RATE] = 1 / [H PERIOD] / [TOTAL V LINES] * 1000000
@@ -266,7 +265,7 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
     left_margin = margins ?
         rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :
         0.0;
-    
+
     /*  16. Find number of pixels in right margin:
      *
      *  [RIGHT MARGIN (PIXELS)] = (IF( [MARGINS RQD?]="Y",
@@ -274,11 +273,11 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *                   [CELL GRAN RND]),0)) * [CELL GRAN RND],
      *          0))
      */
-    
+
     right_margin = margins ?
         rint(h_pixels_rnd * MARGIN_PERCENT / 100.0 / CELL_GRAN) * CELL_GRAN :
         0.0;
-    
+
     /*  17. Find total number of active pixels in image and left and right
      *  margins:
      *
@@ -287,7 +286,7 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      */
 
     total_active_pixels = h_pixels_rnd + left_margin + right_margin;
-    
+
     /*  18. Find the ideal blanking duty cycle from the blanking duty cycle
      *  equation:
      *
@@ -295,7 +294,7 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      */
 
     ideal_duty_cycle = C_PRIME - (M_PRIME * h_period / 1000.0);
-    
+
     /*  19. Find the number of pixels in the blanking time to the nearest
      *  double character cell:
      *
@@ -310,34 +309,32 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
                    ideal_duty_cycle /
                    (100.0 - ideal_duty_cycle) /
                    (2.0 * CELL_GRAN)) * (2.0 * CELL_GRAN);
-    
+
     /*  20. Find total number of pixels:
      *
      *  [TOTAL PIXELS] = [TOTAL ACTIVE PIXELS] + [H BLANK (PIXELS)]
      */
 
     total_pixels = total_active_pixels + h_blank;
-    
+
     /*  21. Find pixel clock frequency:
      *
      *  [PIXEL FREQ] = [TOTAL PIXELS] / [H PERIOD]
      */
-    
+
     pixel_freq = total_pixels / h_period;
-    
+
     /*  22. Find horizontal frequency:
      *
      *  [H FREQ] = 1000 / [H PERIOD]
      */
 
     h_freq = 1000.0 / h_period;
-    
 
     /* Stage 1 computations are now complete; I should really pass
        the results to another function and do the Stage 2
        computations, but I only need a few more values so I'll just
        append the computations here for now */
-    
 
     /*  17. Find the number of pixels in the horizontal sync period:
      *
@@ -345,7 +342,8 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *                             [CELL GRAN RND]),0))*[CELL GRAN RND]
      */
 
-    h_sync = rint(H_SYNC_PERCENT/100.0 * total_pixels / CELL_GRAN) * CELL_GRAN;
+    h_sync =
+        rint(H_SYNC_PERCENT / 100.0 * total_pixels / CELL_GRAN) * CELL_GRAN;
 
     /*  18. Find the number of pixels in the horizontal front porch period:
      *
@@ -358,30 +356,30 @@ xf86GTFMode(int h_pixels, int v_lines, float freq, int interlaced, int margins)
      *
      *  [V ODD FRONT PORCH(LINES)]=([MIN PORCH RND]+[INTERLACE])
      */
-    
+
     v_odd_front_porch_lines = MIN_PORCH + interlace;
-    
+
     /* finally, pack the results in the mode struct */
 
-    mode->HDisplay	= (int) (h_pixels_rnd);
-    mode->HSyncStart	= (int) (h_pixels_rnd + h_front_porch);
-    mode->HSyncEnd	= (int) (h_pixels_rnd + h_front_porch + h_sync);
-    mode->HTotal	= (int) (total_pixels);
-    mode->VDisplay	= (int) (v_lines_rnd);
-    mode->VSyncStart	= (int) (v_lines_rnd + v_odd_front_porch_lines);
-    mode->VSyncEnd	= (int) (v_lines_rnd + v_odd_front_porch_lines + V_SYNC_RQD);
-    mode->VTotal	= (int) (total_v_lines);
+    mode->HDisplay = (int) (h_pixels_rnd);
+    mode->HSyncStart = (int) (h_pixels_rnd + h_front_porch);
+    mode->HSyncEnd = (int) (h_pixels_rnd + h_front_porch + h_sync);
+    mode->HTotal = (int) (total_pixels);
+    mode->VDisplay = (int) (v_lines_rnd);
+    mode->VSyncStart = (int) (v_lines_rnd + v_odd_front_porch_lines);
+    mode->VSyncEnd = (int) (v_lines_rnd + v_odd_front_porch_lines + V_SYNC_RQD);
+    mode->VTotal = (int) (total_v_lines);
 
-    mode->Clock	    = (int) (pixel_freq * 1000.0);
-    mode->HSync	    = h_freq;
-    mode->VRefresh  = freq;
+    mode->Clock = (int) (pixel_freq * 1000.0);
+    mode->HSync = h_freq;
+    mode->VRefresh = freq;
 
     xf86SetModeDefaultName(mode);
 
     mode->Flags = V_NHSYNC | V_PVSYNC;
     if (interlaced) {
-	mode->VTotal *= 2;
-	mode->Flags |= V_INTERLACE;
+        mode->VTotal *= 2;
+        mode->Flags |= V_INTERLACE;
     }
 
     return mode;