Merge remote-tracking branch 'origin/released'

Conflicts:
	mesalib/src/glsl/glsl_symbol_table.h
	mesalib/src/mesa/drivers/common/meta_blit.c
	xorg-server/dix/dispatch.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/mi/miexpose.c

146 files changed, 2857 insertions, 3124 deletions

diff --git a/fontconfig/conf.d/30-metric-aliases.conf b/fontconfig/conf.d/30-metric-aliases.conf
index 08c8ba328..49a960247 100644
--- a/fontconfig/conf.d/30-metric-aliases.conf
+++ b/fontconfig/conf.d/30-metric-aliases.conf
@@ -77,15 +77,12 @@ but in an order preferring similar designs first.  We do this in three steps:
 	  </default>
 	</alias>
 
-<!--
-     Due to Bug#73291, commented out those lines until the broken font are fixed.
 	<alias binding="same">
 	  <family>TeX Gyre Termes</family>
 	  <default>
 	  <family>Times</family>
 	  </default>
 	</alias>
--->
 
 	<alias binding="same">
 	  <family>Nimbus Mono L</family>
@@ -418,10 +415,7 @@ but in an order preferring similar designs first.  We do this in three steps:
 	<alias binding="same">
 	  <family>Times</family>
 	  <accept>
-<!--
-     Due to Bug#73291, commented out this line until the broken font are fixed.
 	  <family>TeX Gyre Termes</family>
--->
 	  <family>Nimbus Roman No9 L</family>
 	  </accept>
 	</alias>
diff --git a/libxcb/check-pc-requires b/libxcb/check-pc-requires
index 0fd9c6597..063356fb4 100644
--- a/libxcb/check-pc-requires
+++ b/libxcb/check-pc-requires
@@ -23,7 +23,7 @@ for inc in src/*.h; do
 		included=`grep '# *include' $inc |
 			sed -e 's/[^<"]*[<"]//' -e 's/[>"]//' |
 			grep -v 'xcb.h\|xproto.h'`
-		requires=`grep '^Requires:' $pcin`
+		requires=`grep '^Requires.private:' $pcin`
 		missing=""
 		for i in $included; do
 			ibase=`basename $i .h`
@@ -58,7 +58,7 @@ for inc in src/*.h; do
 		*)
 			if [ "$fix" = "y" ]; then
 			    echo $package adding dependency on $missing
-			    sed -i '/^Requires:/s/$/ '"$missing"'/' $pcin
+			    sed -i '/^Requires.private:/s/$/ '"$missing"'/' $pcin
 			else
 			    echo $package missing $missing
 			    status=1
diff --git a/libxcb/xcb-composite.pc.in b/libxcb/xcb-composite.pc.in
index 02d49b0c2..b9b74c207 100644
--- a/libxcb/xcb-composite.pc.in
+++ b/libxcb/xcb-composite.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Composite
 Description: XCB Composite Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-xfixes
+Requires.private: xcb xcb-xfixes
 Libs: -L${libdir} -lxcb-composite
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-damage.pc.in b/libxcb/xcb-damage.pc.in
index c4bc59986..3fb46b7f6 100644
--- a/libxcb/xcb-damage.pc.in
+++ b/libxcb/xcb-damage.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Damage
 Description: XCB Damage Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-xfixes
+Requires.private: xcb xcb-xfixes
 Libs: -L${libdir} -lxcb-damage
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-dpms.pc.in b/libxcb/xcb-dpms.pc.in
index 838a054be..281861cff 100644
--- a/libxcb/xcb-dpms.pc.in
+++ b/libxcb/xcb-dpms.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB DPMS
 Description: XCB DPMS Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-dpms
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-dri2.pc.in b/libxcb/xcb-dri2.pc.in
index a9944dfa2..fdb188b00 100644
--- a/libxcb/xcb-dri2.pc.in
+++ b/libxcb/xcb-dri2.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB DRI2
 Description: XCB DRI2 Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-dri2
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-dri3.pc.in b/libxcb/xcb-dri3.pc.in
index 0eb73908a..befe11ea6 100644
--- a/libxcb/xcb-dri3.pc.in
+++ b/libxcb/xcb-dri3.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB DRI3
 Description: XCB DRI3 Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-dri3
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-glx.pc.in b/libxcb/xcb-glx.pc.in
index bbd412675..79805efe9 100644
--- a/libxcb/xcb-glx.pc.in
+++ b/libxcb/xcb-glx.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB GLX
 Description: XCB GLX Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-glx
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-present.pc.in b/libxcb/xcb-present.pc.in
index e2eccc489..2e0cff8e7 100644
--- a/libxcb/xcb-present.pc.in
+++ b/libxcb/xcb-present.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Present
 Description: XCB Present Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-randr xcb-xfixes xcb-sync
+Requires.private: xcb xcb-randr xcb-xfixes xcb-sync
 Libs: -L${libdir} -lxcb-present
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-randr.pc.in b/libxcb/xcb-randr.pc.in
index 09c3d12e2..4c0de13f6 100644
--- a/libxcb/xcb-randr.pc.in
+++ b/libxcb/xcb-randr.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB RandR
 Description: XCB RandR Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-render
+Requires.private: xcb xcb-render
 Libs: -L${libdir} -lxcb-randr
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-record.pc.in b/libxcb/xcb-record.pc.in
index 689f098fc..b441c9a82 100644
--- a/libxcb/xcb-record.pc.in
+++ b/libxcb/xcb-record.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Record
 Description: XCB Record Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-record
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-render.pc.in b/libxcb/xcb-render.pc.in
index c3b050ab6..9ad543e89 100644
--- a/libxcb/xcb-render.pc.in
+++ b/libxcb/xcb-render.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Render
 Description: XCB Render Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-render
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-res.pc.in b/libxcb/xcb-res.pc.in
index 62dbab63e..1f2889de8 100644
--- a/libxcb/xcb-res.pc.in
+++ b/libxcb/xcb-res.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Res
 Description: XCB X-Resource Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-res
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-screensaver.pc.in b/libxcb/xcb-screensaver.pc.in
index ba3f8ecf3..1209b20ab 100644
--- a/libxcb/xcb-screensaver.pc.in
+++ b/libxcb/xcb-screensaver.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Screensaver
 Description: XCB Screensaver Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-screensaver
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-shape.pc.in b/libxcb/xcb-shape.pc.in
index 880204d8a..09637b4a1 100644
--- a/libxcb/xcb-shape.pc.in
+++ b/libxcb/xcb-shape.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Shape
 Description: XCB Shape Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-shape
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-shm.pc.in b/libxcb/xcb-shm.pc.in
index 9256bf015..47c193b8f 100644
--- a/libxcb/xcb-shm.pc.in
+++ b/libxcb/xcb-shm.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Shm
 Description: XCB Shm Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-shm
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-sync.pc.in b/libxcb/xcb-sync.pc.in
index ead76d166..7a4c31511 100644
--- a/libxcb/xcb-sync.pc.in
+++ b/libxcb/xcb-sync.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Sync
 Description: XCB Sync Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-sync
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xevie.pc.in b/libxcb/xcb-xevie.pc.in
index 0aa3e02ac..dc4fee4e2 100644
--- a/libxcb/xcb-xevie.pc.in
+++ b/libxcb/xcb-xevie.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Xevie
 Description: XCB Xevie Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xevie
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xf86dri.pc.in b/libxcb/xcb-xf86dri.pc.in
index f3f29806d..87c93d56f 100644
--- a/libxcb/xcb-xf86dri.pc.in
+++ b/libxcb/xcb-xf86dri.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XFree86-DRI
 Description: XCB XFree86-DRI Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xf86dri
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xfixes.pc.in b/libxcb/xcb-xfixes.pc.in
index 93eafda30..2ebb9cfb2 100644
--- a/libxcb/xcb-xfixes.pc.in
+++ b/libxcb/xcb-xfixes.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XFixes
 Description: XCB XFixes Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-render xcb-shape
+Requires.private: xcb xcb-render xcb-shape
 Libs: -L${libdir} -lxcb-xfixes
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xinerama.pc.in b/libxcb/xcb-xinerama.pc.in
index c4775f9b5..abc3012c8 100644
--- a/libxcb/xcb-xinerama.pc.in
+++ b/libxcb/xcb-xinerama.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Xinerama
 Description: XCB Xinerama Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xinerama
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xinput.pc.in b/libxcb/xcb-xinput.pc.in
index ff34ab470..1f1bb2725 100644
--- a/libxcb/xcb-xinput.pc.in
+++ b/libxcb/xcb-xinput.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XInput
 Description: XCB XInput Extension (EXPERIMENTAL)
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-xfixes
+Requires.private: xcb xcb-xfixes
 Libs: -L${libdir} -lxcb-xinput
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xkb.pc.in b/libxcb/xcb-xkb.pc.in
index 6ed003581..d5b1bad7e 100644
--- a/libxcb/xcb-xkb.pc.in
+++ b/libxcb/xcb-xkb.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XKB
 Description: XCB Keyboard Extension (EXPERIMENTAL)
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xkb
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xprint.pc.in b/libxcb/xcb-xprint.pc.in
index b5275d5d5..7ac65f66c 100644
--- a/libxcb/xcb-xprint.pc.in
+++ b/libxcb/xcb-xprint.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Xprint
 Description: XCB Xprint Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xprint
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xselinux.pc.in b/libxcb/xcb-xselinux.pc.in
index 6a71f733a..0f86a9351 100644
--- a/libxcb/xcb-xselinux.pc.in
+++ b/libxcb/xcb-xselinux.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB SELinux
 Description: XCB SELinux Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xselinux
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xtest.pc.in b/libxcb/xcb-xtest.pc.in
index 886c4dc2f..996115210 100644
--- a/libxcb/xcb-xtest.pc.in
+++ b/libxcb/xcb-xtest.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XTEST
 Description: XCB XTEST Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb
+Requires.private: xcb
 Libs: -L${libdir} -lxcb-xtest
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xv.pc.in b/libxcb/xcb-xv.pc.in
index f4476135f..f31de1ab9 100644
--- a/libxcb/xcb-xv.pc.in
+++ b/libxcb/xcb-xv.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB Xv
 Description: XCB Xv Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-shm
+Requires.private: xcb xcb-shm
 Libs: -L${libdir} -lxcb-xv
 Cflags: -I${includedir}
diff --git a/libxcb/xcb-xvmc.pc.in b/libxcb/xcb-xvmc.pc.in
index 95bf4effc..93c51a933 100644
--- a/libxcb/xcb-xvmc.pc.in
+++ b/libxcb/xcb-xvmc.pc.in
@@ -6,6 +6,6 @@ includedir=@includedir@
 Name: XCB XvMC
 Description: XCB XvMC Extension
 Version: @PACKAGE_VERSION@
-Requires: xcb xcb-xv
+Requires.private: xcb xcb-xv
 Libs: -L${libdir} -lxcb-xvmc
 Cflags: -I${includedir}
diff --git a/mesalib/Android.mk b/mesalib/Android.mk
index 591c2fc51..e190f749b 100644
--- a/mesalib/Android.mk
+++ b/mesalib/Android.mk
@@ -81,6 +81,7 @@ SUBDIRS := \
 	src/mapi \
 	src/glsl \
 	src/mesa \
+	src/util \
 	src/egl/main
 
 ifeq ($(strip $(MESA_BUILD_CLASSIC)),true)
diff --git a/mesalib/configure.ac b/mesalib/configure.ac
index 2a5c143b6..680dff4ab 100644
--- a/mesalib/configure.ac
+++ b/mesalib/configure.ac
@@ -2163,6 +2163,7 @@ AC_CONFIG_FILES([Makefile
 		src/gallium/drivers/svga/Makefile
 		src/gallium/drivers/trace/Makefile
 		src/gallium/drivers/vc4/Makefile
+		src/gallium/drivers/vc4/kernel/Makefile
 		src/gallium/state_trackers/clover/Makefile
 		src/gallium/state_trackers/dri/Makefile
 		src/gallium/state_trackers/egl/Makefile
diff --git a/mesalib/src/gallium/auxiliary/Android.mk b/mesalib/src/gallium/auxiliary/Android.mk
index 11fc2256a..8046943c1 100644
--- a/mesalib/src/gallium/auxiliary/Android.mk
+++ b/mesalib/src/gallium/auxiliary/Android.mk
@@ -30,7 +30,9 @@ include $(CLEAR_VARS)
 
 LOCAL_SRC_FILES := $(C_SOURCES)
 
-LOCAL_C_INCLUDES := $(GALLIUM_TOP)/auxiliary/util
+LOCAL_C_INCLUDES := \
+	$(GALLIUM_TOP)/auxiliary/util \
+	$(MESA_TOP)/src
 
 LOCAL_MODULE := libmesa_gallium
 
diff --git a/mesalib/src/gallium/auxiliary/Makefile.sources b/mesalib/src/gallium/auxiliary/Makefile.sources
index 58d8af71f..f6621ef99 100644
--- a/mesalib/src/gallium/auxiliary/Makefile.sources
+++ b/mesalib/src/gallium/auxiliary/Makefile.sources
@@ -75,6 +75,7 @@ C_SOURCES := \
 	tgsi/tgsi_exec.c \
 	tgsi/tgsi_info.c \
 	tgsi/tgsi_iterate.c \
+	tgsi/tgsi_lowering.c \
 	tgsi/tgsi_parse.c \
 	tgsi/tgsi_sanity.c \
 	tgsi/tgsi_scan.c \
diff --git a/mesalib/src/gallium/auxiliary/hud/hud_context.c b/mesalib/src/gallium/auxiliary/hud/hud_context.c
index b6e018423..18a878118 100644
--- a/mesalib/src/gallium/auxiliary/hud/hud_context.c
+++ b/mesalib/src/gallium/auxiliary/hud/hud_context.c
@@ -44,6 +44,7 @@
 #include "util/u_inlines.h"
 #include "util/u_memory.h"
 #include "util/u_math.h"
+#include "util/u_sampler.h"
 #include "util/u_simple_shaders.h"
 #include "util/u_string.h"
 #include "util/u_upload_mgr.h"
@@ -1050,12 +1051,8 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso)
    }
 
    /* sampler view */
-   memset(&view_templ, 0, sizeof(view_templ));
-   view_templ.format = hud->font.texture->format;
-   view_templ.swizzle_r = PIPE_SWIZZLE_RED;
-   view_templ.swizzle_g = PIPE_SWIZZLE_GREEN;
-   view_templ.swizzle_b = PIPE_SWIZZLE_BLUE;
-   view_templ.swizzle_a = PIPE_SWIZZLE_ALPHA;
+   u_sampler_view_default_template(
+         &view_templ, hud->font.texture, hud->font.texture->format);
    hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
                                                       &view_templ);
 
diff --git a/mesalib/src/gallium/auxiliary/util/u_math.h b/mesalib/src/gallium/auxiliary/util/u_math.h
index 39bd40fa1..f95c11166 100644
--- a/mesalib/src/gallium/auxiliary/util/u_math.h
+++ b/mesalib/src/gallium/auxiliary/util/u_math.h
@@ -727,6 +727,18 @@ util_bitcount(unsigned n)
 #endif
 }
 
+
+static INLINE unsigned
+util_bitcount64(uint64_t n)
+{
+#ifdef HAVE___BUILTIN_POPCOUNTLL
+   return __builtin_popcountll(n);
+#else
+   return util_bitcount(n) + util_bitcount(n >> 32);
+#endif
+}
+
+
 /**
  * Reverse bits in n
  * Algorithm taken from:
diff --git a/mesalib/src/gallium/auxiliary/util/u_pstipple.c b/mesalib/src/gallium/auxiliary/util/u_pstipple.c
index 4f2e70234..509f815c5 100644
--- a/mesalib/src/gallium/auxiliary/util/u_pstipple.c
+++ b/mesalib/src/gallium/auxiliary/util/u_pstipple.c
@@ -407,7 +407,6 @@ util_pstipple_create_fragment_shader(struct pipe_context *pipe,
    struct pipe_shader_state *new_fs;
    struct pstip_transform_context transform;
    const uint newLen = tgsi_num_tokens(fs->tokens) + NUM_NEW_TOKENS;
-   unsigned i;
 
    new_fs = MALLOC(sizeof(*new_fs));
    if (!new_fs)
@@ -433,11 +432,8 @@ util_pstipple_create_fragment_shader(struct pipe_context *pipe,
 
    tgsi_scan_shader(fs->tokens, &transform.info);
 
-   /* find fragment coordinate origin property */
-   for (i = 0; i < transform.info.num_properties; i++) {
-      if (transform.info.properties[i].name == TGSI_PROPERTY_FS_COORD_ORIGIN)
-         transform.coordOrigin = transform.info.properties[i].data[0];
-   }
+   transform.coordOrigin =
+      transform.info.properties[TGSI_PROPERTY_FS_COORD_ORIGIN];
 
    tgsi_transform_shader(fs->tokens,
                          (struct tgsi_token *) new_fs->tokens,
diff --git a/mesalib/src/glsl/Android.mk b/mesalib/src/glsl/Android.mk
index 7b1fa7e53..1cbc5c6d2 100644
--- a/mesalib/src/glsl/Android.mk
+++ b/mesalib/src/glsl/Android.mk
@@ -39,6 +39,7 @@ LOCAL_SRC_FILES := \
 	$(LIBGLSL_FILES)
 
 LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/mapi \
 	$(MESA_TOP)/src/mesa
 
@@ -59,10 +60,11 @@ LOCAL_SRC_FILES := \
 	$(GLSL_COMPILER_CXX_FILES)
 
 LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/mapi \
 	$(MESA_TOP)/src/mesa
 
-LOCAL_STATIC_LIBRARIES := libmesa_glsl libmesa_glsl_utils
+LOCAL_STATIC_LIBRARIES := libmesa_glsl libmesa_glsl_utils libmesa_util
 
 LOCAL_MODULE_TAGS := eng
 LOCAL_MODULE := glsl_compiler
diff --git a/mesalib/src/glsl/Makefile.sources b/mesalib/src/glsl/Makefile.sources
index bfb699353..0c55327d6 100644
--- a/mesalib/src/glsl/Makefile.sources
+++ b/mesalib/src/glsl/Makefile.sources
@@ -96,6 +96,7 @@ LIBGLSL_FILES = \
 	$(GLSL_SRCDIR)/opt_flip_matrices.cpp \
 	$(GLSL_SRCDIR)/opt_function_inlining.cpp \
 	$(GLSL_SRCDIR)/opt_if_simplification.cpp \
+	$(GLSL_SRCDIR)/opt_minmax.cpp \
 	$(GLSL_SRCDIR)/opt_noop_swizzle.cpp \
 	$(GLSL_SRCDIR)/opt_rebalance_tree.cpp \
 	$(GLSL_SRCDIR)/opt_redundant_jumps.cpp \
diff --git a/mesalib/src/glsl/builtin_functions.cpp b/mesalib/src/glsl/builtin_functions.cpp
index 2cdaddea7..4cd76f6b8 100755
--- a/mesalib/src/glsl/builtin_functions.cpp
+++ b/mesalib/src/glsl/builtin_functions.cpp
@@ -442,6 +442,7 @@ private:
    ir_swizzle *matrix_elt(ir_variable *var, int col, int row);
 
    ir_expression *asin_expr(ir_variable *x);
+   void do_atan(ir_factory &body, const glsl_type *type, ir_variable *res, operand y_over_x);
 
    /**
     * Call function \param f with parameters specified as the linked
@@ -2684,11 +2685,7 @@ builtin_builder::_atan2(const glsl_type *type)
       ir_factory outer_then(&outer_if->then_instructions, mem_ctx);
 
       /* Then...call atan(y/x) */
-      ir_variable *y_over_x = outer_then.make_temp(glsl_type::float_type, "y_over_x");
-      outer_then.emit(assign(y_over_x, div(y, x)));
-      outer_then.emit(assign(r, mul(y_over_x, rsq(add(mul(y_over_x, y_over_x),
-                                                      imm(1.0f))))));
-      outer_then.emit(assign(r, asin_expr(r)));
+      do_atan(body, glsl_type::float_type, r, div(y, x));
 
       /*     ...and fix it up: */
       ir_if *inner_if = new(mem_ctx) ir_if(less(x, imm(0.0f)));
@@ -2711,17 +2708,65 @@ builtin_builder::_atan2(const glsl_type *type)
    return sig;
 }
 
+void
+builtin_builder::do_atan(ir_factory &body, const glsl_type *type, ir_variable *res, operand y_over_x)
+{
+   /*
+    * range-reduction, first step:
+    *
+    *      / y_over_x         if |y_over_x| <= 1.0;
+    * x = <
+    *      \ 1.0 / y_over_x   otherwise
+    */
+   ir_variable *x = body.make_temp(type, "atan_x");
+   body.emit(assign(x, div(min2(abs(y_over_x),
+                                imm(1.0f)),
+                           max2(abs(y_over_x),
+                                imm(1.0f)))));
+
+   /*
+    * approximate atan by evaluating polynomial:
+    *
+    * x   * 0.9999793128310355 - x^3  * 0.3326756418091246 +
+    * x^5 * 0.1938924977115610 - x^7  * 0.1173503194786851 +
+    * x^9 * 0.0536813784310406 - x^11 * 0.0121323213173444
+    */
+   ir_variable *tmp = body.make_temp(type, "atan_tmp");
+   body.emit(assign(tmp, mul(x, x)));
+   body.emit(assign(tmp, mul(add(mul(sub(mul(add(mul(sub(mul(add(mul(imm(-0.0121323213173444f),
+                                                                     tmp),
+                                                                 imm(0.0536813784310406f)),
+                                                             tmp),
+                                                         imm(0.1173503194786851f)),
+                                                     tmp),
+                                                 imm(0.1938924977115610f)),
+                                             tmp),
+                                         imm(0.3326756418091246f)),
+                                     tmp),
+                                 imm(0.9999793128310355f)),
+                             x)));
+
+   /* range-reduction fixup */
+   body.emit(assign(tmp, add(tmp,
+                             mul(b2f(greater(abs(y_over_x),
+                                          imm(1.0f, type->components()))),
+                                  add(mul(tmp,
+                                          imm(-2.0f)),
+                                      imm(M_PI_2f))))));
+
+   /* sign fixup */
+   body.emit(assign(res, mul(tmp, sign(y_over_x))));
+}
+
 ir_function_signature *
 builtin_builder::_atan(const glsl_type *type)
 {
    ir_variable *y_over_x = in_var(type, "y_over_x");
    MAKE_SIG(type, always_available, 1, y_over_x);
 
-   ir_variable *t = body.make_temp(type, "t");
-   body.emit(assign(t, mul(y_over_x, rsq(add(mul(y_over_x, y_over_x),
-                                             imm(1.0f))))));
-
-   body.emit(ret(asin_expr(t)));
+   ir_variable *tmp = body.make_temp(type, "tmp");
+   do_atan(body, type, tmp, y_over_x);
+   body.emit(ret(tmp));
 
    return sig;
 }
@@ -4465,9 +4510,11 @@ builtin_builder::_image_prototype(const glsl_type *image_type,
       sig->parameters.push_tail(in_var(glsl_type::int_type, "sample"));
 
    /* Data arguments. */
-   for (unsigned i = 0; i < num_arguments; ++i)
-      sig->parameters.push_tail(in_var(data_type,
-                                       ralloc_asprintf(NULL, "arg%d", i)));
+   for (unsigned i = 0; i < num_arguments; ++i) {
+      char *arg_name = ralloc_asprintf(NULL, "arg%d", i);
+      sig->parameters.push_tail(in_var(data_type, arg_name));
+      ralloc_free(arg_name);
+   }
 
    /* Set the maximal set of qualifiers allowed for this image
     * built-in.  Function calls with arguments having fewer
diff --git a/mesalib/src/glsl/glsl_parser_extras.cpp b/mesalib/src/glsl/glsl_parser_extras.cpp
index cc7d2d746..79f849465 100644
--- a/mesalib/src/glsl/glsl_parser_extras.cpp
+++ b/mesalib/src/glsl/glsl_parser_extras.cpp
@@ -1613,6 +1613,7 @@ do_common_optimization(exec_list *ir, bool linked,
    else
       progress = do_constant_variable_unlinked(ir) || progress;
    progress = do_constant_folding(ir) || progress;
+   progress = do_minmax_prune(ir) || progress;
    progress = do_cse(ir) || progress;
    progress = do_rebalance_tree(ir) || progress;
    progress = do_algebraic(ir, native_integers, options) || progress;
diff --git a/mesalib/src/glsl/glsl_symbol_table.h b/mesalib/src/glsl/glsl_symbol_table.h
index db8863a20..21b02e919 100644..100755
--- a/mesalib/src/glsl/glsl_symbol_table.h
+++ b/mesalib/src/glsl/glsl_symbol_table.h
@@ -43,42 +43,13 @@ struct glsl_type;
  * type safe and some symbol table invariants.
  */
 struct glsl_symbol_table {
-private:
-   static void
-   _glsl_symbol_table_destructor (glsl_symbol_table *table)
-   {
-      table->~glsl_symbol_table();
-   }
-
-public:
-   /* Callers of this ralloc-based new need not call delete. It's
-    * easier to just ralloc_free 'ctx' (or any of its ancestors). */
-   static void* operator new(size_t size, void *ctx)
-   {
-      void *table;
-
-      table = ralloc_size(ctx, size);
-      assert(table != NULL);
-
-      ralloc_set_destructor(table, (void (*)(void*)) _glsl_symbol_table_destructor);
-
-      return table;
-   }
-
-   /* If the user *does* call delete, that's OK, we will just
-    * ralloc_free in that case. Here, C++ will have already called the
-    * destructor so tell ralloc not to do that again. */
+   DECLARE_RALLOC_CXX_OPERATORS(glsl_symbol_table)
    static void operator delete(void *table, void *ctx)
    {
       ralloc_set_destructor(table, NULL);
       ralloc_free(table);
    }
-   static void operator delete(void *table)
-   {
-      ralloc_set_destructor(table, NULL);
-      ralloc_free(table);
-   }
-   
+
    glsl_symbol_table();
    ~glsl_symbol_table();
 
diff --git a/mesalib/src/glsl/ir_optimization.h b/mesalib/src/glsl/ir_optimization.h
index 0c3a63831..e25857ac5 100644
--- a/mesalib/src/glsl/ir_optimization.h
+++ b/mesalib/src/glsl/ir_optimization.h
@@ -99,6 +99,7 @@ bool opt_flatten_nested_if_blocks(exec_list *instructions);
 bool do_discard_simplification(exec_list *instructions);
 bool lower_if_to_cond_assign(exec_list *instructions, unsigned max_depth = 0);
 bool do_mat_op_to_vec(exec_list *instructions);
+bool do_minmax_prune(exec_list *instructions);
 bool do_noop_swizzle(exec_list *instructions);
 bool do_structure_splitting(exec_list *instructions);
 bool do_swizzle_swizzle(exec_list *instructions);
diff --git a/mesalib/src/glsl/link_varyings.cpp b/mesalib/src/glsl/link_varyings.cpp
index a738e2f38..1866ab265 100644
--- a/mesalib/src/glsl/link_varyings.cpp
+++ b/mesalib/src/glsl/link_varyings.cpp
@@ -1456,7 +1456,22 @@ assign_varying_locations(struct gl_context *ctx,
 
          if (var && var->data.mode == ir_var_shader_in &&
              var->data.is_unmatched_generic_inout) {
-            if (prog->Version <= 120) {
+            if (prog->IsES) {
+               /*
+                * On Page 91 (Page 97 of the PDF) of the GLSL ES 1.0 spec:
+                *
+                *     If the vertex shader declares but doesn't write to a
+                *     varying and the fragment shader declares and reads it,
+                *     is this an error?
+                *
+                *     RESOLUTION: No.
+                */
+               linker_warning(prog, "%s shader varying %s not written "
+                              "by %s shader\n.",
+                              _mesa_shader_stage_to_string(consumer->Stage),
+                              var->name,
+                              _mesa_shader_stage_to_string(producer->Stage));
+            } else if (prog->Version <= 120) {
                /* On page 25 (page 31 of the PDF) of the GLSL 1.20 spec:
                 *
                 *     Only those varying variables used (i.e. read) in
@@ -1469,7 +1484,6 @@ assign_varying_locations(struct gl_context *ctx,
                 * write the variable for the FS to read it.  See
                 * "glsl1-varying read but not written" in piglit.
                 */
-
                linker_error(prog, "%s shader varying %s not written "
                             "by %s shader\n.",
                             _mesa_shader_stage_to_string(consumer->Stage),
diff --git a/mesalib/src/glsl/loop_analysis.h b/mesalib/src/glsl/loop_analysis.h
index 31be4f3cf..3b1971d7e 100644
--- a/mesalib/src/glsl/loop_analysis.h
+++ b/mesalib/src/glsl/loop_analysis.h
@@ -140,22 +140,7 @@ public:
       hash_table_dtor(this->var_hash);
    }
 
-   static void* operator new(size_t size, void *ctx)
-   {
-      void *lvs = ralloc_size(ctx, size);
-      assert(lvs != NULL);
-
-      ralloc_set_destructor(lvs, (void (*)(void*)) destructor);
-
-      return lvs;
-   }
-
-private:
-   static void
-   destructor(loop_variable_state *lvs)
-   {
-      lvs->~loop_variable_state();
-   }
+   DECLARE_RALLOC_CXX_OPERATORS(loop_variable_state)
 };
 
 
diff --git a/mesalib/src/glsl/opt_minmax.cpp b/mesalib/src/glsl/opt_minmax.cpp
new file mode 100644
index 000000000..32fb2d7ea
--- /dev/null
+++ b/mesalib/src/glsl/opt_minmax.cpp
@@ -0,0 +1,475 @@
+/*
+ * Copyright © 2014 Intel Corporation
+ *
+ * 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
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * 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 MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+/**
+ * \file opt_minmax.cpp
+ *
+ * Drop operands from an expression tree of only min/max operations if they
+ * can be proven to not contribute to the final result.
+ *
+ * The algorithm is similar to alpha-beta pruning on a minmax search.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_rvalue_visitor.h"
+#include "ir_optimization.h"
+#include "ir_builder.h"
+#include "program/prog_instruction.h"
+#include "glsl_types.h"
+#include "main/macros.h"
+
+using namespace ir_builder;
+
+namespace {
+
+enum compare_components_result {
+   LESS,
+   LESS_OR_EQUAL,
+   EQUAL,
+   GREATER_OR_EQUAL,
+   GREATER,
+   MIXED
+};
+
+class minmax_range {
+public:
+   minmax_range(ir_constant *low = NULL, ir_constant *high = NULL)
+   {
+      this->low = low;
+      this->high = high;
+   }
+
+   /* low is the lower limit of the range, high is the higher limit. NULL on
+    * low means negative infinity (unlimited) and on high positive infinity
+    * (unlimited). Because of the two interpretations of the value NULL,
+    * arbitrary comparison between ir_constants is impossible.
+    */
+   ir_constant *low;
+   ir_constant *high;
+};
+
+class ir_minmax_visitor : public ir_rvalue_enter_visitor {
+public:
+   ir_minmax_visitor()
+      : progress(false)
+   {
+   }
+
+   ir_rvalue *prune_expression(ir_expression *expr, minmax_range baserange);
+
+   void handle_rvalue(ir_rvalue **rvalue);
+
+   bool progress;
+};
+
+/*
+ * Returns LESS if all vector components of `a' are strictly lower than of `b',
+ * GREATER if all vector components of `a' are strictly greater than of `b',
+ * MIXED if some vector components of `a' are strictly lower than of `b' while
+ * others are strictly greater, or EQUAL otherwise.
+ */
+static enum compare_components_result
+compare_components(ir_constant *a, ir_constant *b)
+{
+   assert(a != NULL);
+   assert(b != NULL);
+
+   assert(a->type->base_type == b->type->base_type);
+
+   unsigned a_inc = a->type->is_scalar() ? 0 : 1;
+   unsigned b_inc = b->type->is_scalar() ? 0 : 1;
+   unsigned components = MAX2(a->type->components(), b->type->components());
+
+   bool foundless = false;
+   bool foundgreater = false;
+   bool foundequal = false;
+
+   for (unsigned i = 0, c0 = 0, c1 = 0;
+        i < components;
+        c0 += a_inc, c1 += b_inc, ++i) {
+      switch (a->type->base_type) {
+      case GLSL_TYPE_UINT:
+         if (a->value.u[c0] < b->value.u[c1])
+            foundless = true;
+         else if (a->value.u[c0] > b->value.u[c1])
+            foundgreater = true;
+         else
+            foundequal = true;
+         break;
+      case GLSL_TYPE_INT:
+         if (a->value.i[c0] < b->value.i[c1])
+            foundless = true;
+         else if (a->value.i[c0] > b->value.i[c1])
+            foundgreater = true;
+         else
+            foundequal = true;
+         break;
+      case GLSL_TYPE_FLOAT:
+         if (a->value.f[c0] < b->value.f[c1])
+            foundless = true;
+         else if (a->value.f[c0] > b->value.f[c1])
+            foundgreater = true;
+         else
+            foundequal = true;
+         break;
+      default:
+         unreachable("not reached");
+      }
+   }
+
+   if (foundless && foundgreater) {
+      /* Some components are strictly lower, others are strictly greater */
+      return MIXED;
+   }
+
+   if (foundequal) {
+       /* It is not mixed, but it is not strictly lower or greater */
+      if (foundless)
+         return LESS_OR_EQUAL;
+      if (foundgreater)
+         return GREATER_OR_EQUAL;
+      return EQUAL;
+   }
+
+   /* All components are strictly lower or strictly greater */
+   return foundless ? LESS : GREATER;
+}
+
+static ir_constant *
+combine_constant(bool ismin, ir_constant *a, ir_constant *b)
+{
+   void *mem_ctx = ralloc_parent(a);
+   ir_constant *c = a->clone(mem_ctx, NULL);
+   for (unsigned i = 0; i < c->type->components(); i++) {
+      switch (c->type->base_type) {
+      case GLSL_TYPE_UINT:
+         if ((ismin && b->value.u[i] < c->value.u[i]) ||
+             (!ismin && b->value.u[i] > c->value.u[i]))
+            c->value.u[i] = b->value.u[i];
+         break;
+      case GLSL_TYPE_INT:
+         if ((ismin && b->value.i[i] < c->value.i[i]) ||
+             (!ismin && b->value.i[i] > c->value.i[i]))
+            c->value.i[i] = b->value.i[i];
+         break;
+      case GLSL_TYPE_FLOAT:
+         if ((ismin && b->value.f[i] < c->value.f[i]) ||
+             (!ismin && b->value.f[i] > c->value.f[i]))
+            c->value.f[i] = b->value.f[i];
+         break;
+      default:
+         assert(!"not reached");
+      }
+   }
+   return c;
+}
+
+static ir_constant *
+smaller_constant(ir_constant *a, ir_constant *b)
+{
+   assert(a != NULL);
+   assert(b != NULL);
+
+   enum compare_components_result ret = compare_components(a, b);
+   if (ret == MIXED)
+      return combine_constant(true, a, b);
+   else if (ret < EQUAL)
+      return a;
+   else
+      return b;
+}
+
+static ir_constant *
+larger_constant(ir_constant *a, ir_constant *b)
+{
+   assert(a != NULL);
+   assert(b != NULL);
+
+   enum compare_components_result ret = compare_components(a, b);
+   if (ret == MIXED)
+      return combine_constant(false, a, b);
+   else if (ret < EQUAL)
+      return b;
+   else
+      return a;
+}
+
+/* Combines two ranges by doing an element-wise min() / max() depending on the
+ * operation.
+ */
+static minmax_range
+combine_range(minmax_range r0, minmax_range r1, bool ismin)
+{
+   minmax_range ret;
+
+   if (!r0.low) {
+      ret.low = ismin ? r0.low : r1.low;
+   } else if (!r1.low) {
+      ret.low = ismin ? r1.low : r0.low;
+   } else {
+      ret.low = ismin ? smaller_constant(r0.low, r1.low) :
+         larger_constant(r0.low, r1.low);
+   }
+
+   if (!r0.high) {
+      ret.high = ismin ? r1.high : r0.high;
+   } else if (!r1.high) {
+      ret.high = ismin ? r0.high : r1.high;
+   } else {
+      ret.high = ismin ? smaller_constant(r0.high, r1.high) :
+         larger_constant(r0.high, r1.high);
+   }
+
+   return ret;
+}
+
+/* Returns a range so that lower limit is the larger of the two lower limits,
+ * and higher limit is the smaller of the two higher limits.
+ */
+static minmax_range
+range_intersection(minmax_range r0, minmax_range r1)
+{
+   minmax_range ret;
+
+   if (!r0.low)
+      ret.low = r1.low;
+   else if (!r1.low)
+      ret.low = r0.low;
+   else
+      ret.low = larger_constant(r0.low, r1.low);
+
+   if (!r0.high)
+      ret.high = r1.high;
+   else if (!r1.high)
+      ret.high = r0.high;
+   else
+      ret.high = smaller_constant(r0.high, r1.high);
+
+   return ret;
+}
+
+static minmax_range
+get_range(ir_rvalue *rval)
+{
+   ir_expression *expr = rval->as_expression();
+   if (expr && (expr->operation == ir_binop_min ||
+                expr->operation == ir_binop_max)) {
+      minmax_range r0 = get_range(expr->operands[0]);
+      minmax_range r1 = get_range(expr->operands[1]);
+      return combine_range(r0, r1, expr->operation == ir_binop_min);
+   }
+
+   ir_constant *c = rval->as_constant();
+   if (c) {
+      return minmax_range(c, c);
+   }
+
+   return minmax_range();
+}
+
+/**
+ * Prunes a min/max expression considering the base range of the parent
+ * min/max expression.
+ *
+ * @param baserange the range that the parents of this min/max expression
+ * in the min/max tree will clamp its value to.
+ */
+ir_rvalue *
+ir_minmax_visitor::prune_expression(ir_expression *expr, minmax_range baserange)
+{
+   assert(expr->operation == ir_binop_min ||
+          expr->operation == ir_binop_max);
+
+   bool ismin = expr->operation == ir_binop_min;
+   minmax_range limits[2];
+
+   /* Recurse to get the ranges for each of the subtrees of this
+    * expression. We need to do this as a separate step because we need to
+    * know the ranges of each of the subtrees before we prune either one.
+    * Consider something like this:
+    *
+    *        max
+    *     /       \
+    *    max     max
+    *   /   \   /   \
+    *  3    a   b    2
+    *
+    * We would like to prune away the max on the bottom-right, but to do so
+    * we need to know the range of the expression on the left beforehand,
+    * and there's no guarantee that we will visit either subtree in a
+    * particular order.
+    */
+   for (unsigned i = 0; i < 2; ++i)
+      limits[i] = get_range(expr->operands[i]);
+
+   for (unsigned i = 0; i < 2; ++i) {
+      bool is_redundant = false;
+
+      enum compare_components_result cr = LESS;
+      if (ismin) {
+         /* If this operand will always be greater than the other one, it's
+          * redundant.
+          */
+         if (limits[i].low && limits[1 - i].high) {
+               cr = compare_components(limits[i].low, limits[1 - i].high);
+            if (cr >= EQUAL && cr != MIXED)
+               is_redundant = true;
+         }
+         /* If this operand is always greater than baserange, then even if
+          * it's smaller than the other one it'll get clamped, so it's
+          * redundant.
+          */
+         if (!is_redundant && limits[i].low && baserange.high) {
+            cr = compare_components(limits[i].low, baserange.high);
+            if (cr >= EQUAL && cr != MIXED)
+               is_redundant = true;
+         }
+      } else {
+         /* If this operand will always be lower than the other one, it's
+          * redundant.
+          */
+         if (limits[i].high && limits[1 - i].low) {
+            cr = compare_components(limits[i].high, limits[1 - i].low);
+            if (cr <= EQUAL)
+               is_redundant = true;
+         }
+         /* If this operand is always lower than baserange, then even if
+          * it's greater than the other one it'll get clamped, so it's
+          * redundant.
+          */
+         if (!is_redundant && limits[i].high && baserange.low) {
+            cr = compare_components(limits[i].high, baserange.low);
+            if (cr <= EQUAL)
+               is_redundant = true;
+         }
+      }
+
+      if (is_redundant) {
+         progress = true;
+
+         /* Recurse if necessary. */
+         ir_expression *op_expr = expr->operands[1 - i]->as_expression();
+         if (op_expr && (op_expr->operation == ir_binop_min ||
+                         op_expr->operation == ir_binop_max)) {
+            return prune_expression(op_expr, baserange);
+         }
+
+         return expr->operands[1 - i];
+      } else if (cr == MIXED) {
+         /* If we have mixed vector operands, we can try to resolve the minmax
+          * expression by doing a component-wise minmax:
+          *
+          *             min                          min
+          *           /    \                       /    \
+          *         min     a       ===>        [1,1]    a
+          *       /    \
+          *    [1,3]   [3,1]
+          *
+          */
+         ir_constant *a = expr->operands[0]->as_constant();
+         ir_constant *b = expr->operands[1]->as_constant();
+         if (a && b)
+            return combine_constant(ismin, a, b);
+      }
+   }
+
+   /* Now recurse to operands giving them the proper baserange. The baserange
+    * to pass is the intersection of our baserange and the other operand's
+    * limit with one of the ranges unlimited. If we can't compute a valid
+    * intersection, we use the current baserange.
+    */
+   for (unsigned i = 0; i < 2; ++i) {
+      ir_expression *op_expr = expr->operands[i]->as_expression();
+      if (op_expr && (op_expr->operation == ir_binop_min ||
+                      op_expr->operation == ir_binop_max)) {
+         /* We can only compute a new baserange for this operand if we managed
+          * to compute a valid range for the other operand.
+          */
+         if (ismin)
+            limits[1 - i].low = NULL;
+         else
+            limits[1 - i].high = NULL;
+         minmax_range base = range_intersection(limits[1 - i], baserange);
+         expr->operands[i] = prune_expression(op_expr, base);
+      }
+   }
+
+   /* If we got here we could not discard any of the operands of the minmax
+    * expression, but we can still try to resolve the expression if both
+    * operands are constant. We do this after the loop above, to make sure
+    * that if our operands are minmax expressions we have tried to prune them
+    * first (hopefully reducing them to constants).
+    */
+   ir_constant *a = expr->operands[0]->as_constant();
+   ir_constant *b = expr->operands[1]->as_constant();
+   if (a && b)
+      return combine_constant(ismin, a, b);
+
+   return expr;
+}
+
+static ir_rvalue *
+swizzle_if_required(ir_expression *expr, ir_rvalue *rval)
+{
+   if (expr->type->is_vector() && rval->type->is_scalar()) {
+      return swizzle(rval, SWIZZLE_XXXX, expr->type->vector_elements);
+   } else {
+      return rval;
+   }
+}
+
+void
+ir_minmax_visitor::handle_rvalue(ir_rvalue **rvalue)
+{
+   if (!*rvalue)
+      return;
+
+   ir_expression *expr = (*rvalue)->as_expression();
+   if (!expr || (expr->operation != ir_binop_min &&
+                 expr->operation != ir_binop_max))
+      return;
+
+   ir_rvalue *new_rvalue = prune_expression(expr, minmax_range());
+   if (new_rvalue == *rvalue)
+      return;
+
+   /* If the expression type is a vector and the optimization leaves a scalar
+    * as the result, we need to turn it into a vector.
+    */
+   *rvalue = swizzle_if_required(expr, new_rvalue);
+
+   progress = true;
+}
+
+}
+
+bool
+do_minmax_prune(exec_list *instructions)
+{
+   ir_minmax_visitor v;
+
+   visit_list_elements(&v, instructions);
+
+   return v.progress;
+}
diff --git a/mesalib/src/mapi/glapi/gen/glX_proto_recv.py b/mesalib/src/mapi/glapi/gen/glX_proto_recv.py
index 086fc97d7..84a404ce3 100755
--- a/mesalib/src/mapi/glapi/gen/glX_proto_recv.py
+++ b/mesalib/src/mapi/glapi/gen/glX_proto_recv.py
@@ -449,6 +449,8 @@ class PrintGlxDispatchFunctions(glX_proto_common.glx_print_proto):
             elif param.counter:
                 print '        %s answerBuffer[200];' %  (answer_type)
                 print '        %s %s = __glXGetAnswerBuffer(cl, %s%s, answerBuffer, sizeof(answerBuffer), %u);' % (param.type_string(), param.name, param.counter, size_scale, type_size)
+                print '        if (%s == NULL)' % (param.name)
+                print '            return BadAlloc;'
                 answer_string = param.name
                 answer_count = param.counter
             elif c >= 1:
diff --git a/mesalib/src/mesa/Android.gen.mk b/mesalib/src/mesa/Android.gen.mk
index c6280f5cb..c7b7f7edf 100644
--- a/mesalib/src/mesa/Android.gen.mk
+++ b/mesalib/src/mesa/Android.gen.mk
@@ -115,3 +115,12 @@ GET_HASH_GEN := $(LOCAL_PATH)/main/get_hash_generator.py
 $(intermediates)/main/get_hash.h: $(glapi)/gl_and_es_API.xml \
                $(LOCAL_PATH)/main/get_hash_params.py $(GET_HASH_GEN)
 	@$(MESA_PYTHON2) $(GET_HASH_GEN) -f $< > $@
+
+FORMAT_INFO := $(LOCAL_PATH)/main/format_info.py
+format_info_deps := \
+	$(LOCAL_PATH)/main/formats.csv \
+	$(LOCAL_PATH)/main/format_parser.py \
+	$(FORMAT_INFO)
+
+$(intermediates)/main/format_info.c: $(format_info_deps)
+	@$(MESA_PYTHON2) $(FORMAT_INFO) $< > $@
diff --git a/mesalib/src/mesa/Android.libmesa_dricore.mk b/mesalib/src/mesa/Android.libmesa_dricore.mk
index 28d6feb35..1e6d94872 100644
--- a/mesalib/src/mesa/Android.libmesa_dricore.mk
+++ b/mesalib/src/mesa/Android.libmesa_dricore.mk
@@ -32,6 +32,8 @@ LOCAL_PATH := $(call my-dir)
 #     MESA_FILES
 #     X86_FILES
 include $(LOCAL_PATH)/Makefile.sources
+SRCDIR :=
+BUILDDIR :=
 
 include $(CLEAR_VARS)
 
@@ -55,6 +57,7 @@ endif
 
 LOCAL_C_INCLUDES := \
 	$(call intermediates-dir-for STATIC_LIBRARIES,libmesa_program,,) \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/mapi \
 	$(MESA_TOP)/src/glsl \
 	$(MESA_TOP)/src/gallium/auxiliary
diff --git a/mesalib/src/mesa/Android.libmesa_glsl_utils.mk b/mesalib/src/mesa/Android.libmesa_glsl_utils.mk
index e93891f07..a9f6ff59a 100644
--- a/mesalib/src/mesa/Android.libmesa_glsl_utils.mk
+++ b/mesalib/src/mesa/Android.libmesa_glsl_utils.mk
@@ -36,11 +36,11 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := libmesa_glsl_utils
 
 LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/glsl \
 	$(MESA_TOP)/src/mapi
 
 LOCAL_SRC_FILES := \
-	main/hash_table.c \
 	main/imports.c \
 	program/prog_hash_table.c \
 	program/symbol_table.c
@@ -59,11 +59,11 @@ LOCAL_IS_HOST_MODULE := true
 LOCAL_CFLAGS := -D_POSIX_C_SOURCE=199309L
 
 LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/glsl \
 	$(MESA_TOP)/src/mapi
 
 LOCAL_SRC_FILES := \
-	main/hash_table.c \
 	main/imports.c \
 	program/prog_hash_table.c \
 	program/symbol_table.c
diff --git a/mesalib/src/mesa/Android.libmesa_st_mesa.mk b/mesalib/src/mesa/Android.libmesa_st_mesa.mk
index e6374a6d8..8b8d652a3 100644
--- a/mesalib/src/mesa/Android.libmesa_st_mesa.mk
+++ b/mesalib/src/mesa/Android.libmesa_st_mesa.mk
@@ -32,6 +32,8 @@ LOCAL_PATH := $(call my-dir)
 # 	MESA_GALLIUM_FILES.
 # 	X86_FILES
 include $(LOCAL_PATH)/Makefile.sources
+SRCDIR :=
+BUILDDIR :=
 
 include $(CLEAR_VARS)
 
@@ -50,6 +52,7 @@ LOCAL_C_INCLUDES := \
 	$(call intermediates-dir-for STATIC_LIBRARIES,libmesa_program,,) \
 	$(MESA_TOP)/src/gallium/auxiliary \
 	$(MESA_TOP)/src/gallium/include \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/glsl \
 	$(MESA_TOP)/src/mapi
 
diff --git a/mesalib/src/mesa/drivers/common/meta_blit.c b/mesalib/src/mesa/drivers/common/meta_blit.c
index 4ac75e74b..c6616d93d 100644..100755
--- a/mesalib/src/mesa/drivers/common/meta_blit.c
+++ b/mesalib/src/mesa/drivers/common/meta_blit.c
@@ -45,6 +45,7 @@
 #include "main/texenv.h"
 #include "main/teximage.h"
 #include "main/texparam.h"
+#include "main/uniforms.h"
 #include "main/varray.h"
 #include "main/viewport.h"
 #include "swrast/swrast.h"
@@ -69,7 +70,7 @@ setup_glsl_msaa_blit_scaled_shader(struct gl_context *ctx,
    const uint8_t *sample_map;
    char *sample_map_str = rzalloc_size(mem_ctx, 1);
    char *sample_map_expr = rzalloc_size(mem_ctx, 1);
-   char *texel_fetch_macro = rzalloc_size(mem_ctx, 1);;
+   char *texel_fetch_macro = rzalloc_size(mem_ctx, 1);
    const char *vs_source;
    const char *sampler_array_suffix = "";
    const char *texcoord_type = "vec2";
@@ -105,11 +106,11 @@ setup_glsl_msaa_blit_scaled_shader(struct gl_context *ctx,
       _mesa_UseProgram(blit->msaa_shaders[shader_index]);
       /* Update the uniform values. */
       loc_src_width =
-		  _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
+         _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
       loc_src_height =
-		  _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
-	  _mesa_Uniform1f(loc_src_width, src_rb->Width);
-	  _mesa_Uniform1f(loc_src_height, src_rb->Height);
+         _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
+      _mesa_Uniform1f(loc_src_width, src_rb->Width);
+      _mesa_Uniform1f(loc_src_height, src_rb->Height);
       return;
    }
 
@@ -218,9 +219,9 @@ setup_glsl_msaa_blit_scaled_shader(struct gl_context *ctx,
    _mesa_meta_compile_and_link_program(ctx, vs_source, fs_source, name,
                                        &blit->msaa_shaders[shader_index]);
    loc_src_width =
-	   _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
+      _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
    loc_src_height =
-	   _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
+      _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
    _mesa_Uniform1f(loc_src_width, src_rb->Width);
    _mesa_Uniform1f(loc_src_height, src_rb->Height);
 
diff --git a/mesalib/src/mesa/main/api_validate.c b/mesalib/src/mesa/main/api_validate.c
index 51a3d1f01..9b80600de 100644
--- a/mesalib/src/mesa/main/api_validate.c
+++ b/mesalib/src/mesa/main/api_validate.c
@@ -112,9 +112,8 @@ check_valid_to_render(struct gl_context *ctx, const char *function)
 
    switch (ctx->API) {
    case API_OPENGLES2:
-      /* For ES2, we can draw if any vertex array is enabled (and we
-       * should always have a vertex program/shader). */
-      if (ctx->Array.VAO->_Enabled == 0x0 || !ctx->VertexProgram._Current)
+      /* For ES2, we can draw if we have a vertex program/shader). */
+      if (!ctx->VertexProgram._Current)
 	 return GL_FALSE;
       break;
 
diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index 0edd66d6f..5a8f7184a 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -891,10 +891,24 @@ _mesa_generic_nop(void)
 
 
 /**
- * Allocate and initialize a new dispatch table.
+ * Special no-op glFlush, see below.
+ */
+#if defined(_WIN32)
+static void GLAPIENTRY
+nop_glFlush(void)
+{
+   /* don't record an error like we do in _mesa_generic_nop() */
+}
+#endif
+
+
+/**
+ * Allocate and initialize a new dispatch table.  All the dispatch
+ * function pointers will point at the _mesa_generic_nop() function
+ * which raises GL_INVALID_OPERATION.
  */
 struct _glapi_table *
-_mesa_alloc_dispatch_table()
+_mesa_alloc_dispatch_table(void)
 {
    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
@@ -911,6 +925,26 @@ _mesa_alloc_dispatch_table()
       for (i = 0; i < numEntries; i++) {
          entry[i] = (_glapi_proc) _mesa_generic_nop;
       }
+
+#if defined(_WIN32)
+      /* This is a special case for Windows in the event that
+       * wglGetProcAddress is called between glBegin/End().
+       *
+       * The MS opengl32.dll library apparently calls glFlush from
+       * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
+       * will dispatch to _mesa_generic_nop() and we'll generate a
+       * GL_INVALID_OPERATION error.
+       *
+       * The specific case which hits this is piglit's primitive-restart
+       * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
+       * first time we call glPrimitiveRestartNV() Piglit's API dispatch
+       * code will try to resolve the function by calling wglGetProcAddress.
+       * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
+       * will fail causing the test to fail.  By suppressing the error, the
+       * assertion passes and the test continues.
+       */
+      SET_Flush(table, nop_glFlush);
+#endif
    }
    return table;
 }
diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c
index 2c54e4a35..cb5f7936c 100644
--- a/mesalib/src/mesa/main/texgetimage.c
+++ b/mesalib/src/mesa/main/texgetimage.c
@@ -78,8 +78,8 @@ get_tex_depth(struct gl_context *ctx, GLuint dimensions,
               struct gl_texture_image *texImage)
 {
    const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
+   GLint height = texImage->Height;
+   GLint depth = texImage->Depth;
    GLint img, row;
    GLfloat *depthRow = malloc(width * sizeof(GLfloat));
 
@@ -88,6 +88,11 @@ get_tex_depth(struct gl_context *ctx, GLuint dimensions,
       return;
    }
 
+   if (texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY) {
+      depth = height;
+      height = 1;
+   }
+
    for (img = 0; img < depth; img++) {
       GLubyte *srcMap;
       GLint srcRowStride;
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 647d28ab3..c0298af8e 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -2449,7 +2449,7 @@ texsubimage_error_check(struct gl_context *ctx, GLuint dimensions,
 
    /* level check */
    if (level < 0 || level >= _mesa_max_texture_levels(ctx, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage%uD(level=%d)",
+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%uD(level=%d)",
                   dimensions, level);
       return GL_TRUE;
    }
diff --git a/mesalib/src/mesa/main/varray.c b/mesalib/src/mesa/main/varray.c
index 09bf52c42..96c2b26f7 100644
--- a/mesalib/src/mesa/main/varray.c
+++ b/mesalib/src/mesa/main/varray.c
@@ -1907,10 +1907,10 @@ static void
 print_array(const char *name, GLint index, const struct gl_client_array *array)
 {
    if (index >= 0)
-      printf("  %s[%d]: ", name, index);
+      fprintf(stderr, "  %s[%d]: ", name, index);
    else
-      printf("  %s: ", name);
-   printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %lu)\n",
+      fprintf(stderr, "  %s: ", name);
+   fprintf(stderr, "Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %lu)\n",
 	  array->Ptr, array->Type, array->Size,
 	  array->_ElementSize, array->StrideB,
 	  array->BufferObj->Name, (unsigned long) array->BufferObj->Size);
diff --git a/mesalib/src/mesa/program/Android.mk b/mesalib/src/mesa/program/Android.mk
index e85afe672..19c4be0fe 100644
--- a/mesalib/src/mesa/program/Android.mk
+++ b/mesalib/src/mesa/program/Android.mk
@@ -39,6 +39,8 @@ endef
 # Import the following variables:
 #     PROGRAM_FILES
 include $(MESA_TOP)/src/mesa/Makefile.sources
+SRCDIR :=
+BUILDDIR :=
 
 include $(CLEAR_VARS)
 
@@ -71,6 +73,7 @@ $(intermediates)/program/lex.yy.c: $(LOCAL_PATH)/program_lexer.l
 
 LOCAL_C_INCLUDES := \
 	$(intermediates) \
+	$(MESA_TOP)/src \
 	$(MESA_TOP)/src/mapi \
 	$(MESA_TOP)/src/mesa \
 	$(MESA_TOP)/src/glsl
diff --git a/mesalib/src/util/Android.mk b/mesalib/src/util/Android.mk
new file mode 100644
index 000000000..6b38cf9af
--- /dev/null
+++ b/mesalib/src/util/Android.mk
@@ -0,0 +1,102 @@
+# Mesa 3-D graphics library
+#
+# Copyright (C) 2014 Tomasz Figa <tomasz.figa@gmail.com>
+#
+# 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
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice 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 MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/Makefile.sources
+
+# ---------------------------------------
+# Build libmesa_util
+# ---------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	$(MESA_UTIL_FILES)
+
+LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src/mesa \
+	$(MESA_TOP)/src/mapi \
+	$(MESA_TOP)/src
+
+LOCAL_MODULE := libmesa_util
+
+# Generated sources
+
+ifeq ($(LOCAL_MODULE_CLASS),)
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+endif
+
+intermediates := $(call local-intermediates-dir)
+
+# This is the list of auto-generated files: sources and headers
+sources := $(addprefix $(intermediates)/, $(MESA_UTIL_GENERATED_FILES))
+
+LOCAL_GENERATED_SOURCES += $(sources)
+
+FORMAT_SRGB := $(LOCAL_PATH)/format_srgb.py
+
+$(intermediates)/format_srgb.c: $(FORMAT_SRGB)
+	@$(MESA_PYTHON2) $(FORMAT_SRGB) $< > $@
+
+include $(MESA_COMMON_MK)
+include $(BUILD_STATIC_LIBRARY)
+
+# ---------------------------------------
+# Build host libmesa_util
+# ---------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_IS_HOST_MODULE := true
+LOCAL_CFLAGS := -D_POSIX_C_SOURCE=199309L
+
+LOCAL_SRC_FILES := \
+	$(MESA_UTIL_FILES)
+
+LOCAL_C_INCLUDES := \
+	$(MESA_TOP)/src/mesa \
+	$(MESA_TOP)/src/mapi \
+	$(MESA_TOP)/src
+
+LOCAL_MODULE := libmesa_util
+
+# Generated sources
+
+ifeq ($(LOCAL_MODULE_CLASS),)
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+endif
+
+intermediates := $(call local-intermediates-dir)
+
+# This is the list of auto-generated files: sources and headers
+sources := $(addprefix $(intermediates)/, $(MESA_UTIL_GENERATED_FILES))
+
+LOCAL_GENERATED_SOURCES += $(sources)
+
+FORMAT_SRGB := $(LOCAL_PATH)/format_srgb.py
+
+$(intermediates)/format_srgb.c: $(FORMAT_SRGB)
+	@$(MESA_PYTHON2) $(FORMAT_SRGB) $< > $@
+
+include $(MESA_COMMON_MK)
+include $(BUILD_HOST_STATIC_LIBRARY)
diff --git a/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj b/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj
index af78c2cfe..6096ede51 100644
--- a/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj
+++ b/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj
@@ -249,6 +249,7 @@
     <ClCompile Include="..\..\..\..\src\glsl\opt_flip_matrices.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_function_inlining.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_if_simplification.cpp" />

+    <ClCompile Include="..\..\..\..\src\glsl\opt_minmax.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_noop_swizzle.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_rebalance_tree.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_redundant_jumps.cpp" />

diff --git a/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj.filters b/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj.filters
index 046b9f911..1f603e94c 100644
--- a/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj.filters
+++ b/mesalib/windows/VC8/mesa/glsl_apps_compile/glsl_apps_compile.vcxproj.filters
@@ -312,6 +312,9 @@
     <ClCompile Include="..\..\..\..\src\glsl\opt_dead_builtin_variables.cpp">

       <Filter>Source Files</Filter>

     </ClCompile>

+    <ClCompile Include="..\..\..\..\src\glsl\opt_minmax.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <ClInclude Include="..\..\..\..\src\glsl\strtod.h">

diff --git a/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj b/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj
index 626258f65..a6e90cfac 100644
--- a/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj
+++ b/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj
@@ -288,6 +288,7 @@
     <ClCompile Include="..\..\..\..\src\glsl\opt_flip_matrices.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_function_inlining.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_if_simplification.cpp" />

+    <ClCompile Include="..\..\..\..\src\glsl\opt_minmax.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_noop_swizzle.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_rebalance_tree.cpp" />

     <ClCompile Include="..\..\..\..\src\glsl\opt_redundant_jumps.cpp" />

diff --git a/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj.filters b/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj.filters
index 43c86ea67..fdd848147 100644
--- a/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj.filters
+++ b/mesalib/windows/VC8/mesa/mesa/mesa.vcxproj.filters
@@ -815,6 +815,9 @@
     <ClCompile Include="..\..\..\..\src\glsl\opt_dead_builtin_variables.cpp">

       <Filter>Source Files</Filter>

     </ClCompile>

+    <ClCompile Include="..\..\..\..\src\glsl\opt_minmax.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <ClInclude Include="..\..\..\..\src\glsl\strtod.h">

diff --git a/pixman/pixman/pixman-fast-path.c b/pixman/pixman/pixman-fast-path.c
index c6e43de10..53d4a1f90 100644
--- a/pixman/pixman/pixman-fast-path.c
+++ b/pixman/pixman/pixman-fast-path.c
@@ -2343,6 +2343,8 @@ fast_fetch_bilinear_cover (pixman_iter_t *iter, const uint32_t *mask)
     int32_t dist_y;
     int i;
 
+    COMPILE_TIME_ASSERT (BILINEAR_INTERPOLATION_BITS < 8);
+
     fx = info->x;
     ux = iter->image->common.transform->matrix[0][0];
 
diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h
index fdc966ae9..73108a01d 100644
--- a/pixman/pixman/pixman-private.h
+++ b/pixman/pixman/pixman-private.h
@@ -7,7 +7,7 @@
  * The defines which are shared between C and assembly code
  */
 
-/* bilinear interpolation precision (must be <= 8) */
+/* bilinear interpolation precision (must be < 8) */
 #define BILINEAR_INTERPOLATION_BITS 7
 #define BILINEAR_INTERPOLATION_RANGE (1 << BILINEAR_INTERPOLATION_BITS)
 
diff --git a/tools/plink/sshzlib.c b/tools/plink/sshzlib.c
index 8a64e3563..c69edfb81 100644
--- a/tools/plink/sshzlib.c
+++ b/tools/plink/sshzlib.c
@@ -1234,6 +1234,8 @@ int zlib_decompress_block(void *handle, unsigned char *block, int len,
 		goto finished;
 	    if (code == -2)
 		goto decode_error;
+	    if (code >= 30)            /* dist symbols 30 and 31 are invalid */
+		goto decode_error;
 	    dctx->state = GOTDISTSYM;
 	    dctx->sym = code;
 	    break;
diff --git a/xorg-server/Xext/panoramiXprocs.c b/xorg-server/Xext/panoramiXprocs.c
index 87a2a176c..1714d4b6f 100644
--- a/xorg-server/Xext/panoramiXprocs.c
+++ b/xorg-server/Xext/panoramiXprocs.c
@@ -1191,9 +1191,8 @@ PanoramiXCopyArea(ClientPtr client)
             Bool overlap;
 
             RegionValidate(&totalReg, &overlap);
-            (*pDst->pScreen->SendGraphicsExpose) (client, &totalReg,
-                                                  stuff->dstDrawable,
-                                                  X_CopyArea, 0);
+            SendGraphicsExpose(client, &totalReg, stuff->dstDrawable,
+                               X_CopyArea, 0);
             RegionUninit(&totalReg);
         }
     }
@@ -1304,9 +1303,8 @@ PanoramiXCopyPlane(ClientPtr client)
         Bool overlap;
 
         RegionValidate(&totalReg, &overlap);
-        (*pdstDraw->pScreen->SendGraphicsExpose) (client, &totalReg,
-                                                  stuff->dstDrawable,
-                                                  X_CopyPlane, 0);
+        SendGraphicsExpose(client, &totalReg, stuff->dstDrawable,
+                           X_CopyPlane, 0);
         RegionUninit(&totalReg);
     }
 
diff --git a/xorg-server/Xext/security.c b/xorg-server/Xext/security.c
index b7c53a461..67b3a7e67 100644
--- a/xorg-server/Xext/security.c
+++ b/xorg-server/Xext/security.c
@@ -69,7 +69,6 @@ typedef struct {
 static const char *SecurityTrustedExtensions[] = {
     "XC-MISC",
     "BIG-REQUESTS",
-    "XpExtension",
     NULL
 };
 
diff --git a/xorg-server/composite/compext.c b/xorg-server/composite/compext.c
index 9896f5d41..94a1db245 100644
--- a/xorg-server/composite/compext.c
+++ b/xorg-server/composite/compext.c
@@ -591,9 +591,6 @@ CompositeExtensionInit(void)
         return;
     CompositeReqCode = (CARD8) extEntry->base;
 
-    miRegisterRedirectBorderClipProc(compSetRedirectBorderClip,
-                                     compGetRedirectBorderClip);
-
     /* Initialization succeeded */
     noCompositeExtension = FALSE;
 }
diff --git a/xorg-server/composite/compinit.c b/xorg-server/composite/compinit.c
index 48e938fac..111c16e5d 100644
--- a/xorg-server/composite/compinit.c
+++ b/xorg-server/composite/compinit.c
@@ -119,12 +119,12 @@ compChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
         pScreen->backingStoreSupport != NotUseful) {
         if (pWin->backingStore != NotUseful && !pWin->backStorage) {
             compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic);
-            pWin->backStorage = (void *) (intptr_t) 1;
+            pWin->backStorage = TRUE;
         }
         else if (pWin->backingStore == NotUseful && pWin->backStorage) {
             compUnredirectWindow(serverClient, pWin,
                                  CompositeRedirectAutomatic);
-            pWin->backStorage = NULL;
+            pWin->backStorage = FALSE;
         }
     }
 
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index 30c0c5cd9..c6971889c 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -217,10 +217,12 @@ AC_SUBST(DLOPEN_LIBS)
 
 dnl Checks for library functions.
 AC_CHECK_FUNCS([backtrace ffs geteuid getuid issetugid getresuid \
-	getdtablesize getifaddrs getpeereid getpeerucred getzoneid \
+	getdtablesize getifaddrs getpeereid getpeerucred getprogname getzoneid \
 	mmap seteuid shmctl64 strncasecmp vasprintf vsnprintf walkcontext])
 AC_REPLACE_FUNCS([strcasecmp strcasestr strlcat strlcpy strndup])
 
+AC_CHECK_DECLS([program_invocation_short_name], [], [], [[#include <errno.h>]])
+
 dnl Find the math libary, then check for cbrt function in it.
 AC_CHECK_LIB(m, sqrt)
 AC_CHECK_FUNCS([cbrt])
diff --git a/xorg-server/dix/devices.c b/xorg-server/dix/devices.c
index ce64dfeda..d43d29ded 100644
--- a/xorg-server/dix/devices.c
+++ b/xorg-server/dix/devices.c
@@ -1219,63 +1219,6 @@ QueryMinMaxKeyCodes(KeyCode *minCode, KeyCode *maxCode)
     }
 }
 
-/* Notably, this function does not expand the destination's keycode range, or
- * notify clients. */
-Bool
-SetKeySymsMap(KeySymsPtr dst, KeySymsPtr src)
-{
-    int i, j;
-    KeySym *tmp;
-    int rowDif = src->minKeyCode - dst->minKeyCode;
-
-    /* if keysym map size changes, grow map first */
-    if (src->mapWidth < dst->mapWidth) {
-        for (i = src->minKeyCode; i <= src->maxKeyCode; i++) {
-#define SI(r, c) (((r - src->minKeyCode) * src->mapWidth) + (c))
-#define DI(r, c) (((r - dst->minKeyCode) * dst->mapWidth) + (c))
-            for (j = 0; j < src->mapWidth; j++)
-                dst->map[DI(i, j)] = src->map[SI(i, j)];
-            for (j = src->mapWidth; j < dst->mapWidth; j++)
-                dst->map[DI(i, j)] = NoSymbol;
-#undef SI
-#undef DI
-        }
-        return TRUE;
-    }
-    else if (src->mapWidth > dst->mapWidth) {
-        i = sizeof(KeySym) * src->mapWidth *
-            (dst->maxKeyCode - dst->minKeyCode + 1);
-        tmp = calloc(sizeof(KeySym), i);
-        if (!tmp)
-            return FALSE;
-
-        if (dst->map) {
-            for (i = 0; i <= dst->maxKeyCode - dst->minKeyCode; i++)
-                memmove(&tmp[i * src->mapWidth], &dst->map[i * dst->mapWidth],
-                        dst->mapWidth * sizeof(KeySym));
-            free(dst->map);
-        }
-        dst->mapWidth = src->mapWidth;
-        dst->map = tmp;
-    }
-    else if (!dst->map) {
-        i = sizeof(KeySym) * src->mapWidth *
-            (dst->maxKeyCode - dst->minKeyCode + 1);
-        tmp = calloc(sizeof(KeySym), i);
-        if (!tmp)
-            return FALSE;
-
-        dst->map = tmp;
-        dst->mapWidth = src->mapWidth;
-    }
-
-    memmove(&dst->map[rowDif * dst->mapWidth], src->map,
-            (src->maxKeyCode - src->minKeyCode + 1) *
-            dst->mapWidth * sizeof(KeySym));
-
-    return TRUE;
-}
-
 Bool
 InitButtonClassDeviceStruct(DeviceIntPtr dev, int numButtons, Atom *labels,
                             CARD8 *map)
diff --git a/xorg-server/dix/dispatch.c b/xorg-server/dix/dispatch.c
index f6ed81302..36f9418ca 100755
--- a/xorg-server/dix/dispatch.c
+++ b/xorg-server/dix/dispatch.c
@@ -1643,6 +1643,52 @@ ProcClearToBackground(ClientPtr client)
     return Success;

 }

 

+/* send GraphicsExpose events, or a NoExpose event, based on the region */

+void

+SendGraphicsExpose(ClientPtr client, RegionPtr pRgn, XID drawable,

+                     int major, int minor)

+{

+    if (pRgn && !RegionNil(pRgn)) {

+        xEvent *pEvent;

+        xEvent *pe;

+        BoxPtr pBox;

+        int i;

+        int numRects;

+

+        numRects = RegionNumRects(pRgn);

+        pBox = RegionRects(pRgn);

+        if (!(pEvent = calloc(numRects, sizeof(xEvent))))

+            return;

+        pe = pEvent;

+

+        for (i = 1; i <= numRects; i++, pe++, pBox++) {

+            pe->u.u.type = GraphicsExpose;

+            pe->u.graphicsExposure.drawable = drawable;

+            pe->u.graphicsExposure.x = pBox->x1;

+            pe->u.graphicsExposure.y = pBox->y1;

+            pe->u.graphicsExposure.width = pBox->x2 - pBox->x1;

+            pe->u.graphicsExposure.height = pBox->y2 - pBox->y1;

+            pe->u.graphicsExposure.count = numRects - i;

+            pe->u.graphicsExposure.majorEvent = major;

+            pe->u.graphicsExposure.minorEvent = minor;

+        }

+        /* GraphicsExpose is a "critical event", which TryClientEvents

+         * handles specially. */

+        TryClientEvents(client, NULL, pEvent, numRects,

+                        (Mask) 0, NoEventMask, NullGrab);

+        free(pEvent);

+    }

+    else {

+        xEvent event = {

+            .u.noExposure.drawable = drawable,

+            .u.noExposure.majorEvent = major,

+            .u.noExposure.minorEvent = minor

+        };

+        event.u.u.type = NoExpose;

+        WriteEventsToClient(client, 1, &event);

+    }

+}

+

 int

 ProcCopyArea(ClientPtr client)

 {

@@ -1674,8 +1720,7 @@ ProcCopyArea(ClientPtr client)
                                   stuff->width, stuff->height,

                                   stuff->dstX, stuff->dstY);

     if (pGC->graphicsExposures) {

-        (*pDst->pScreen->SendGraphicsExpose)

-            (client, pRgn, stuff->dstDrawable, X_CopyArea, 0);

+        SendGraphicsExpose(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);

         if (pRgn)

             RegionDestroy(pRgn);

     }

@@ -1722,8 +1767,7 @@ ProcCopyPlane(ClientPtr client)
                                 stuff->srcY, stuff->width, stuff->height,

                                 stuff->dstX, stuff->dstY, stuff->bitPlane);

     if (pGC->graphicsExposures) {

-        (*pdstDraw->pScreen->SendGraphicsExpose)

-            (client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);

+        SendGraphicsExpose(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);

         if (pRgn)

             RegionDestroy(pRgn);

     }

diff --git a/xorg-server/dix/protocol.txt b/xorg-server/dix/protocol.txt
index f83f38c58..c22379581 100644
--- a/xorg-server/dix/protocol.txt
+++ b/xorg-server/dix/protocol.txt
@@ -1082,33 +1082,3 @@ R009 XVideo-MotionCompensation:GetDRInfo
 E000 XVideo-MotionCompensation:BadContext
 E001 XVideo-MotionCompensation:BadSurface
 E002 XVideo-MotionCompensation:BadSubpicture
-R000 XpExtension:QueryVersion
-R001 XpExtension:GetPrinterList
-R002 XpExtension:CreateContext
-R003 XpExtension:SetContext
-R004 XpExtension:GetContext
-R005 XpExtension:DestroyContext
-R006 XpExtension:GetContextScreen
-R007 XpExtension:StartJob
-R008 XpExtension:EndJob
-R009 XpExtension:StartDoc
-R010 XpExtension:EndDoc
-R011 XpExtension:PutDocumentData
-R012 XpExtension:GetDocumentData
-R013 XpExtension:StartPage
-R014 XpExtension:EndPage
-R015 XpExtension:SelectInput
-R016 XpExtension:InputSelected
-R017 XpExtension:GetAttributes
-R018 XpExtension:SetAttributes
-R019 XpExtension:GetOneAttribute
-R020 XpExtension:RehashPrinterList
-R021 XpExtension:GetPageDimensions
-R022 XpExtension:QueryScreens
-R023 XpExtension:SetImageResolution
-R024 XpExtension:GetImageResolution
-V000 XpExtension:PrintNotify
-V001 XpExtension:AttributeNotify
-E000 XpExtension:BadContext
-E001 XpExtension:BadSequence
-E002 XpExtension:BadResourceID
diff --git a/xorg-server/dix/window.c b/xorg-server/dix/window.c
index 7bbfc719b..4af933fa6 100644
--- a/xorg-server/dix/window.c
+++ b/xorg-server/dix/window.c
@@ -357,13 +357,12 @@ SetWindowToDefaults(WindowPtr pWin)
     pWin->firstChild = NullWindow;
     pWin->lastChild = NullWindow;
 
-    pWin->valdata = (ValidatePtr) NULL;
-    pWin->optional = (WindowOptPtr) NULL;
+    pWin->valdata = NULL;
+    pWin->optional = NULL;
     pWin->cursorIsNone = TRUE;
 
     pWin->backingStore = NotUseful;
-    pWin->DIXsaveUnder = FALSE;
-    pWin->backStorage = (void *) NULL;
+    pWin->backStorage = 0;
 
     pWin->mapped = FALSE;       /* off */
     pWin->realized = FALSE;     /* off */
@@ -1555,7 +1554,7 @@ MoveWindowInStack(WindowPtr pWin, WindowPtr pNextSib)
             if (pWin->prevSib)
                 pWin->prevSib->nextSib = pWin->nextSib;
             pWin->nextSib = pParent->firstChild;
-            pWin->prevSib = (WindowPtr) NULL;
+            pWin->prevSib = NULL;
             pNextSib->prevSib = pWin;
             pParent->firstChild = pWin;
         }
@@ -1817,8 +1816,6 @@ ResizeChildrenWinSize(WindowPtr pWin, int dx, int dy, int dw, int dh)
 
 #define ChangeMask ((Mask)(CWX | CWY | CWWidth | CWHeight))
 
-#define IllegalInputOnlyConfigureMask (CWBorderWidth)
-
 /*
  * IsSiblingAboveMe
  *     returns Above if pSib above pMe in stack or Below otherwise 
@@ -1852,7 +1849,7 @@ WindowExtents(WindowPtr pWin, BoxPtr pBox)
     return pBox;
 }
 
-#define IS_SHAPED(pWin)	(wBoundingShape (pWin) != (RegionPtr) NULL)
+#define IS_SHAPED(pWin)	(wBoundingShape (pWin) != NULL)
 
 static RegionPtr
 MakeBoundingRegion(WindowPtr pWin, BoxPtr pBox)
@@ -1958,7 +1955,7 @@ WhereDoIGoInTheStack(WindowPtr pWin,
     WindowPtr pHead, pFirst;
 
     if ((pWin == pWin->parent->firstChild) && (pWin == pWin->parent->lastChild))
-        return ((WindowPtr) NULL);
+        return NULL;
     pHead = RealChildHead(pWin->parent);
     pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
     box.x1 = x;
@@ -2066,10 +2063,10 @@ ReflectStackChange(WindowPtr pWin, WindowPtr pSib, VTKind kind)
         if (anyMarked) {
             (*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind);
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pWin->drawable.pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
+                                              kind);
         }
-        if (anyMarked && pWin->drawable.pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
-                                          kind);
     }
     if (pWin->realized)
         WindowsRestructured();
@@ -2096,8 +2093,7 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
         h = pWin->drawable.height, bw = pWin->borderWidth;
     int rc, action, smode = Above;
 
-    if ((pWin->drawable.class == InputOnly) &&
-        (mask & IllegalInputOnlyConfigureMask))
+    if ((pWin->drawable.class == InputOnly) && (mask & CWBorderWidth))
         return BadMatch;
 
     if ((mask & CWSibling) && !(mask & CWStackMode))
@@ -2583,10 +2579,10 @@ MapWindow(WindowPtr pWin, ClientPtr client)
             if (anyMarked) {
                 (*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTMap);
                 (*pScreen->HandleExposures) (pLayerWin->parent);
+                if (pScreen->PostValidateTree)
+                    (*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
+                                                  VTMap);
             }
-            if (anyMarked && pScreen->PostValidateTree)
-                (*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
-                                              VTMap);
         }
         WindowsRestructured();
     }
@@ -2604,7 +2600,7 @@ MapWindow(WindowPtr pWin, ClientPtr client)
             (*pScreen->PostValidateTree) (NullWindow, pWin, VTMap);
         RegionNull(&temp);
         RegionCopy(&temp, &pWin->clipList);
-        (*pScreen->WindowExposures) (pWin, &temp, NullRegion);
+        (*pScreen->WindowExposures) (pWin, &temp);
         RegionUninit(&temp);
     }
 
@@ -2648,8 +2644,7 @@ MapSubwindows(WindowPtr pParent, ClientPtr client)
                 RealizeTree(pWin);
                 if (pWin->viewable) {
                     anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin,
-                                                                    (WindowPtr
-                                                                     *) NULL);
+                                                                    NULL);
                 }
             }
         }
@@ -2659,17 +2654,16 @@ MapSubwindows(WindowPtr pParent, ClientPtr client)
         pLayerWin = (*pScreen->GetLayerWindow) (pParent);
         if (pLayerWin->parent != pParent) {
             anyMarked |= (*pScreen->MarkOverlappedWindows) (pLayerWin,
-                                                            pLayerWin,
-                                                            (WindowPtr *) NULL);
+                                                            pLayerWin, NULL);
             pFirstMapped = pLayerWin;
         }
         if (anyMarked) {
             (*pScreen->ValidateTree) (pLayerWin->parent, pFirstMapped, VTMap);
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstMapped,
+                                              VTMap);
         }
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstMapped,
-                                          VTMap);
         WindowsRestructured();
     }
 }
@@ -2763,9 +2757,9 @@ UnmapWindow(WindowPtr pWin, Bool fromConfigure)
         if (!fromConfigure) {
             (*pScreen->ValidateTree) (pLayerWin->parent, pWin, VTUnmap);
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pWin, VTUnmap);
         }
-        if (!fromConfigure && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pWin, VTUnmap);
     }
     if (wasRealized && !fromConfigure) {
         WindowsRestructured();
@@ -2810,8 +2804,6 @@ UnmapSubwindows(WindowPtr pWin)
             pChild->mapped = FALSE;
             if (pChild->realized)
                 UnrealizeTree(pChild, FALSE);
-            if (wasViewable) {
-            }
         }
     }
     if (wasViewable) {
@@ -2821,8 +2813,7 @@ UnmapSubwindows(WindowPtr pWin)
             else {
                 WindowPtr ptmp;
 
-                (*pScreen->MarkOverlappedWindows) (pWin, pLayerWin,
-                                                   (WindowPtr *) NULL);
+                (*pScreen->MarkOverlappedWindows) (pWin, pLayerWin, NULL);
                 (*pScreen->MarkWindow) (pLayerWin->parent);
 
                 /* Windows between pWin and pLayerWin may not have been marked */
@@ -2836,9 +2827,10 @@ UnmapSubwindows(WindowPtr pWin)
             }
             (*pScreen->ValidateTree) (pLayerWin->parent, pHead, VTUnmap);
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pHead,
+                                              VTUnmap);
         }
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pHead, VTUnmap);
     }
     if (wasRealized) {
         WindowsRestructured();
@@ -2881,7 +2873,7 @@ HandleSaveSet(ClientPtr client)
     }
     free(client->saveSet);
     client->numSaved = 0;
-    client->saveSet = (SaveSetElt *) NULL;
+    client->saveSet = NULL;
 }
 
 /**
@@ -3597,22 +3589,19 @@ SetRootClip(ScreenPtr pScreen, Bool enable)
         if (pWin->firstChild) {
             anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin->firstChild,
                                                             pWin->firstChild,
-                                                            (WindowPtr *) NULL);
+                                                            NULL);
         }
         else {
             (*pScreen->MarkWindow) (pWin);
             anyMarked = TRUE;
         }
 
-        if (anyMarked)
+        if (anyMarked) {
             (*pScreen->ValidateTree) (pWin, NullWindow, VTOther);
-    }
-
-    if (WasViewable) {
-        if (anyMarked)
             (*pScreen->HandleExposures) (pWin);
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pWin, NullWindow, VTOther);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pWin, NullWindow, VTOther);
+        }
     }
     if (pWin->realized)
         WindowsRestructured();
diff --git a/xorg-server/exa/exa_priv.h b/xorg-server/exa/exa_priv.h
index 61a1f4ccb..88bfd3772 100644
--- a/xorg-server/exa/exa_priv.h
+++ b/xorg-server/exa/exa_priv.h
@@ -214,18 +214,6 @@ typedef struct {
     DevPrivateKeyRec gcPrivateKeyRec;
 } ExaScreenPrivRec, *ExaScreenPrivPtr;
 
-/*
- * This is the only completely portable way to
- * compute this info.
- */
-#ifndef BitsPerPixel
-#define BitsPerPixel(d) (\
-    PixmapWidthPaddingInfo[d].notPower2 ? \
-    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
-    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
-    (PixmapWidthPaddingInfo[d].padRoundUp+1)))
-#endif
-
 extern DevPrivateKeyRec exaScreenPrivateKeyRec;
 
 #define exaScreenPrivateKey (&exaScreenPrivateKeyRec)
diff --git a/xorg-server/fb/fb.h b/xorg-server/fb/fb.h
index 90577677b..d176bb343 100644
--- a/xorg-server/fb/fb.h
+++ b/xorg-server/fb/fb.h
@@ -1621,13 +1621,13 @@ extern _X_EXPORT Bool
  fbDestroyWindow(WindowPtr pWin);
 
 extern _X_EXPORT Bool
- fbMapWindow(WindowPtr pWindow);
+ fbRealizeWindow(WindowPtr pWindow);
 
 extern _X_EXPORT Bool
  fbPositionWindow(WindowPtr pWin, int x, int y);
 
 extern _X_EXPORT Bool
- fbUnmapWindow(WindowPtr pWindow);
+ fbUnrealizeWindow(WindowPtr pWindow);
 
 extern _X_EXPORT void
 
diff --git a/xorg-server/fb/fbcopy.c b/xorg-server/fb/fbcopy.c
index 541ef713b..5bbabc39f 100644
--- a/xorg-server/fb/fbcopy.c
+++ b/xorg-server/fb/fbcopy.c
@@ -271,5 +271,5 @@ fbCopyPlane(DrawablePtr pSrcDrawable,
     else
         return miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
                                  xIn, yIn,
-                                 widthSrc, heightSrc, xOut, yOut, bitplane);
+                                 widthSrc, heightSrc, xOut, yOut);
 }
diff --git a/xorg-server/fb/fboverlay.c b/xorg-server/fb/fboverlay.c
index 935bf1b50..6a5f0f814 100644
--- a/xorg-server/fb/fboverlay.c
+++ b/xorg-server/fb/fboverlay.c
@@ -240,12 +240,11 @@ fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 }
 
 void
-fbOverlayWindowExposures(WindowPtr pWin,
-                         RegionPtr prgn, RegionPtr other_exposed)
+fbOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn)
 {
     fbOverlayUpdateLayerRegion(pWin->drawable.pScreen,
                                fbOverlayWindowLayer(pWin), prgn);
-    miWindowExposures(pWin, prgn, other_exposed);
+    miWindowExposures(pWin, prgn);
 }
 
 Bool
diff --git a/xorg-server/fb/fboverlay.h b/xorg-server/fb/fboverlay.h
index 57c9873c2..47727e4ee 100644
--- a/xorg-server/fb/fboverlay.h
+++ b/xorg-server/fb/fboverlay.h
@@ -82,9 +82,7 @@ extern _X_EXPORT void
  fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
 
 extern _X_EXPORT void
-
-fbOverlayWindowExposures(WindowPtr pWin,
-                         RegionPtr prgn, RegionPtr other_exposed);
+fbOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn);
 
 extern _X_EXPORT Bool
 
diff --git a/xorg-server/fb/fbscreen.c b/xorg-server/fb/fbscreen.c
index 0d4d87f8b..71bcc5d30 100644
--- a/xorg-server/fb/fbscreen.c
+++ b/xorg-server/fb/fbscreen.c
@@ -110,8 +110,8 @@ fbSetupScreen(ScreenPtr pScreen, void *pbits, /* pointer to screen bitmap */
     pScreen->DestroyWindow = fbDestroyWindow;
     pScreen->PositionWindow = fbPositionWindow;
     pScreen->ChangeWindowAttributes = fbChangeWindowAttributes;
-    pScreen->RealizeWindow = fbMapWindow;
-    pScreen->UnrealizeWindow = fbUnmapWindow;
+    pScreen->RealizeWindow = fbRealizeWindow;
+    pScreen->UnrealizeWindow = fbUnrealizeWindow;
     pScreen->CopyWindow = fbCopyWindow;
     pScreen->CreatePixmap = fbCreatePixmap;
     pScreen->DestroyPixmap = fbDestroyPixmap;
diff --git a/xorg-server/fb/fbwindow.c b/xorg-server/fb/fbwindow.c
index c90175faa..7a5fac869 100644
--- a/xorg-server/fb/fbwindow.c
+++ b/xorg-server/fb/fbwindow.c
@@ -46,7 +46,7 @@ fbDestroyWindow(WindowPtr pWin)
 }
 
 Bool
-fbMapWindow(WindowPtr pWindow)
+fbRealizeWindow(WindowPtr pWindow)
 {
     return TRUE;
 }
@@ -58,7 +58,7 @@ fbPositionWindow(WindowPtr pWin, int x, int y)
 }
 
 Bool
-fbUnmapWindow(WindowPtr pWindow)
+fbUnrealizeWindow(WindowPtr pWindow)
 {
     return TRUE;
 }
diff --git a/xorg-server/fb/wfbrename.h b/xorg-server/fb/wfbrename.h
index 94efd03dd..ad5950573 100644
--- a/xorg-server/fb/wfbrename.h
+++ b/xorg-server/fb/wfbrename.h
@@ -86,7 +86,6 @@
 #define fbInstallColormap wfbInstallColormap
 #define fbLaneTable wfbLaneTable
 #define fbListInstalledColormaps wfbListInstalledColormaps
-#define fbMapWindow wfbMapWindow
 #define FbMergeRopBits wFbMergeRopBits
 #define fbOddStipple wfbOddStipple
 #define fbOddTile wfbOddTile
@@ -132,6 +131,7 @@
 #define fbQueryBestSize wfbQueryBestSize
 #define fbRasterizeTrapezoid wfbRasterizeTrapezoid
 #define fbRealizeFont wfbRealizeFont
+#define fbRealizeWindow wfbRealizeWindow
 #define fbReduceRasterOp wfbReduceRasterOp
 #define fbReplicatePixel wfbReplicatePixel
 #define fbResolveColor wfbResolveColor
@@ -158,7 +158,7 @@
 #define fbTrapezoids wfbTrapezoids
 #define fbTriangles wfbTriangles
 #define fbUninstallColormap wfbUninstallColormap
-#define fbUnmapWindow wfbUnmapWindow
+#define fbUnrealizeWindow wfbUnrealizeWindow
 #define fbUnrealizeFont wfbUnrealizeFont
 #define fbValidateGC wfbValidateGC
 #define fbWinPrivateKeyRec wfbWinPrivateKeyRec
diff --git a/xorg-server/glamor/glamor_copy.c b/xorg-server/glamor/glamor_copy.c
index 6f422d419..3320935f0 100644
--- a/xorg-server/glamor/glamor_copy.c
+++ b/xorg-server/glamor/glamor_copy.c
@@ -677,8 +677,7 @@ glamor_copy_plane(DrawablePtr src, DrawablePtr dst, GCPtr gc,
 {
     if ((bitplane & FbFullMask(src->depth)) == 0)
         return miHandleExposures(src, dst, gc,
-                                 srcx, srcy, width, height, dstx, dsty,
-                                 bitplane);
+                                 srcx, srcy, width, height, dstx, dsty);
     return miDoCopy(src, dst, gc,
                     srcx, srcy, width, height,
                     dstx, dsty, glamor_copy, bitplane, NULL);
diff --git a/xorg-server/glx/indirect_dispatch.c b/xorg-server/glx/indirect_dispatch.c
index 67e5280c3..4a274a480 100644..100755
--- a/xorg-server/glx/indirect_dispatch.c
+++ b/xorg-server/glx/indirect_dispatch.c
@@ -2747,6 +2747,8 @@ int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
             n,
              (const GLuint *)(pc +  4),
@@ -2772,6 +2774,8 @@ int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
             n,
              (const GLuint *)(pc +  4),
@@ -2889,6 +2893,8 @@ int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (textures == NULL)
+            return BadAlloc;
         CALL_GenTextures( GET_DISPATCH(), (
             n,
             textures
@@ -2912,6 +2918,8 @@ int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (textures == NULL)
+            return BadAlloc;
         CALL_GenTextures( GET_DISPATCH(), (
             n,
             textures
@@ -4261,6 +4269,8 @@ int __glXDisp_GenQueries(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (ids == NULL)
+            return BadAlloc;
         CALL_GenQueries( GET_DISPATCH(), (
             n,
             ids
@@ -4711,6 +4721,8 @@ int __glXDisp_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (programs == NULL)
+            return BadAlloc;
         CALL_GenProgramsARB( GET_DISPATCH(), (
             n,
             programs
@@ -5086,6 +5098,8 @@ int __glXDisp_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (framebuffers == NULL)
+            return BadAlloc;
         CALL_GenFramebuffers( GET_DISPATCH(), (
             n,
             framebuffers
@@ -5109,6 +5123,8 @@ int __glXDisp_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (renderbuffers == NULL)
+            return BadAlloc;
         CALL_GenRenderbuffers( GET_DISPATCH(), (
             n,
             renderbuffers
@@ -5271,6 +5287,8 @@ int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
             n,
              (const GLuint *)(pc +  4),
diff --git a/xorg-server/glx/indirect_dispatch_swap.c b/xorg-server/glx/indirect_dispatch_swap.c
index 4096023a7..b944c5724 100644..100755
--- a/xorg-server/glx/indirect_dispatch_swap.c
+++ b/xorg-server/glx/indirect_dispatch_swap.c
@@ -2875,6 +2875,8 @@ int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
             n,
              (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
@@ -2900,6 +2902,8 @@ int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreTexturesResident( GET_DISPATCH(), (
             n,
              (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
@@ -3017,6 +3021,8 @@ int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (textures == NULL)
+            return BadAlloc;
         CALL_GenTextures( GET_DISPATCH(), (
             n,
             textures
@@ -3041,6 +3047,8 @@ int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (textures == NULL)
+            return BadAlloc;
         CALL_GenTextures( GET_DISPATCH(), (
             n,
             textures
@@ -4407,6 +4415,8 @@ int __glXDispSwap_GenQueries(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (ids == NULL)
+            return BadAlloc;
         CALL_GenQueries( GET_DISPATCH(), (
             n,
             ids
@@ -4864,6 +4874,8 @@ int __glXDispSwap_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (programs == NULL)
+            return BadAlloc;
         CALL_GenProgramsARB( GET_DISPATCH(), (
             n,
             programs
@@ -5245,6 +5257,8 @@ int __glXDispSwap_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (framebuffers == NULL)
+            return BadAlloc;
         CALL_GenFramebuffers( GET_DISPATCH(), (
             n,
             framebuffers
@@ -5269,6 +5283,8 @@ int __glXDispSwap_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
 
         GLuint answerBuffer[200];
         GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
+        if (renderbuffers == NULL)
+            return BadAlloc;
         CALL_GenRenderbuffers( GET_DISPATCH(), (
             n,
             renderbuffers
@@ -5434,6 +5450,8 @@ int __glXDispSwap_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
         GLboolean retval;
         GLboolean answerBuffer[200];
         GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        if (residences == NULL)
+            return BadAlloc;
         retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
             n,
              (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
diff --git a/xorg-server/hw/dmx/dmxgcops.c b/xorg-server/hw/dmx/dmxgcops.c
index aa7c8eb54..0ebd69a0e 100644
--- a/xorg-server/hw/dmx/dmxgcops.c
+++ b/xorg-server/hw/dmx/dmxgcops.c
@@ -179,7 +179,7 @@ dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
 
     if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
         return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
-                                 dstx, dsty, 0L);
+                                 dstx, dsty);
 
     DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
     DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
@@ -188,7 +188,7 @@ dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
               srcx, srcy, w, h, dstx, dsty);
     dmxSync(dmxScreen, FALSE);
 
-    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0L);
+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
 }
 
 /** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
@@ -206,7 +206,7 @@ dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
 
     if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
         return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-                                 dstx, dsty, bitPlane);
+                                 dstx, dsty);
 
     DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
     DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
@@ -216,7 +216,7 @@ dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
     dmxSync(dmxScreen, FALSE);
 
     return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-                             dstx, dsty, bitPlane);
+                             dstx, dsty);
 }
 
 /** Render list of points, \a pptInit in \a pDrawable on the back-end
diff --git a/xorg-server/hw/dmx/dmxwindow.c b/xorg-server/hw/dmx/dmxwindow.c
index 1c235273c..c75373534 100644
--- a/xorg-server/hw/dmx/dmxwindow.c
+++ b/xorg-server/hw/dmx/dmxwindow.c
@@ -772,7 +772,7 @@ dmxWindowExposurePredicate(Display * dpy, XEvent * ev, XPointer ptr)
  *  in DMX, the events that are generated by the back-end server are
  *  redundant, so we eat them here. */
 void
-dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
+dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn)
 {
     ScreenPtr pScreen = pWindow->drawable.pScreen;
     DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
@@ -799,7 +799,7 @@ dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
 
 #if 1
     if (pScreen->WindowExposures)
-        pScreen->WindowExposures(pWindow, prgn, other_exposed);
+        pScreen->WindowExposures(pWindow, prgn);
 #endif
     DMX_WRAP(WindowExposures, dmxWindowExposures, dmxScreen, pScreen);
 }
diff --git a/xorg-server/hw/dmx/dmxwindow.h b/xorg-server/hw/dmx/dmxwindow.h
index c6b2efee6..dda6538d1 100644
--- a/xorg-server/hw/dmx/dmxwindow.h
+++ b/xorg-server/hw/dmx/dmxwindow.h
@@ -73,8 +73,7 @@ extern Bool dmxChangeWindowAttributes(WindowPtr pWindow, unsigned long mask);
 extern Bool dmxRealizeWindow(WindowPtr pWindow);
 extern Bool dmxUnrealizeWindow(WindowPtr pWindow);
 extern void dmxRestackWindow(WindowPtr pWindow, WindowPtr pOldNextSib);
-extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn,
-                               RegionPtr other_exposed);
+extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn);
 extern void dmxCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg,
                           RegionPtr prgnSrc);
 
diff --git a/xorg-server/hw/kdrive/ephyr/ephyr.c b/xorg-server/hw/kdrive/ephyr/ephyr.c
index ae095c883..66f1de211 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyr.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyr.c
@@ -889,7 +889,7 @@ ephyrExposePairedWindow(int a_remote)
     screen = pair->local->drawable.pScreen;
     RegionNull(&reg);
     RegionCopy(&reg, &pair->local->clipList);
-    screen->WindowExposures(pair->local, &reg, NullRegion);
+    screen->WindowExposures(pair->local, &reg);
     RegionUninit(&reg);
 }
 #endif                          /* XF86DRI */
diff --git a/xorg-server/hw/kdrive/src/kdrive.c b/xorg-server/hw/kdrive/src/kdrive.c
index 0db52729e..e2bd04705 100644
--- a/xorg-server/hw/kdrive/src/kdrive.c
+++ b/xorg-server/hw/kdrive/src/kdrive.c
@@ -911,10 +911,6 @@ KdScreenInit(ScreenPtr pScreen, int argc, char **argv)
         if (!(*card->cfuncs->finishInitScreen) (pScreen))
             return FALSE;
 
-#if 0
-    fbInitValidateTree(pScreen);
-#endif
-
     /*
      * Wrap CloseScreen, the order now is:
      *  KdCloseScreen
diff --git a/xorg-server/hw/kdrive/src/kdrive.h b/xorg-server/hw/kdrive/src/kdrive.h
index 0aae8bb56..fd17f2e9b 100644
--- a/xorg-server/hw/kdrive/src/kdrive.h
+++ b/xorg-server/hw/kdrive/src/kdrive.h
@@ -330,19 +330,6 @@ typedef struct _KdPointerMatrix {
     int matrix[2][3];
 } KdPointerMatrix;
 
-/*
- * This is the only completely portable way to
- * compute this info.
- */
-
-#ifndef BitsPerPixel
-#define BitsPerPixel(d) (\
-    PixmapWidthPaddingInfo[d].notPower2 ? \
-    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
-    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
-    (PixmapWidthPaddingInfo[d].padRoundUp+1)))
-#endif
-
 extern DevPrivateKeyRec kdScreenPrivateKeyRec;
 
 #define kdScreenPrivateKey (&kdScreenPrivateKeyRec)
diff --git a/xorg-server/hw/kdrive/src/kxv.c b/xorg-server/hw/kdrive/src/kxv.c
index f979e1fbd..163d5c1dd 100644
--- a/xorg-server/hw/kdrive/src/kxv.c
+++ b/xorg-server/hw/kdrive/src/kxv.c
@@ -86,7 +86,7 @@ static int KdXVQueryImageAttributes(XvPortPtr, XvImagePtr,
 /* ScreenRec fields */
 
 static Bool KdXVDestroyWindow(WindowPtr pWin);
-static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2);
+static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1);
 static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);
 static Bool KdXVCloseScreen(ScreenPtr);
 
@@ -822,7 +822,7 @@ KdXVDestroyWindow(WindowPtr pWin)
 }
 
 static void
-KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
+KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1)
 {
     ScreenPtr pScreen = pWin->drawable.pScreen;
     KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
@@ -834,7 +834,7 @@ KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
     AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
 
     pScreen->WindowExposures = ScreenPriv->WindowExposures;
-    (*pScreen->WindowExposures) (pWin, reg1, reg2);
+    (*pScreen->WindowExposures) (pWin, reg1);
     pScreen->WindowExposures = KdXVWindowExposures;
 
     /* filter out XClearWindow/Area */
diff --git a/xorg-server/hw/vfb/InitOutput.c b/xorg-server/hw/vfb/InitOutput.c
index 9c4926462..bcaaa85e4 100644
--- a/xorg-server/hw/vfb/InitOutput.c
+++ b/xorg-server/hw/vfb/InitOutput.c
@@ -380,26 +380,10 @@ ddxProcessArgument(int argc, char *argv[], int i)
     return 0;
 }
 
-static DevPrivateKeyRec cmapScrPrivateKeyRec;
-
-#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)
-
-#define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))
-#define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))
-
-static int
-vfbListInstalledColormaps(ScreenPtr pScreen, Colormap * pmaps)
-{
-    /* By the time we are processing requests, we can guarantee that there
-     * is always a colormap installed */
-    *pmaps = GetInstalledColormap(pScreen)->mid;
-    return 1;
-}
-
 static void
 vfbInstallColormap(ColormapPtr pmap)
 {
-    ColormapPtr oldpmap = GetInstalledColormap(pmap->pScreen);
+    ColormapPtr oldpmap = GetInstalledmiColormap(pmap->pScreen);
 
     if (pmap != oldpmap) {
         int entries;
@@ -410,11 +394,7 @@ vfbInstallColormap(ColormapPtr pmap)
         xColorItem *defs;
         int i;
 
-        if (oldpmap != (ColormapPtr) None)
-            WalkTree(pmap->pScreen, TellLostMap, (char *) &oldpmap->mid);
-        /* Install pmap */
-        SetInstalledColormap(pmap->pScreen, pmap);
-        WalkTree(pmap->pScreen, TellGainedMap, (char *) &pmap->mid);
+        miInstallColormap(pmap);
 
         entries = pmap->pVisual->ColormapEntries;
         pXWDHeader = vfbScreens[pmap->pScreen->myNum].pXWDHeader;
@@ -452,28 +432,12 @@ vfbInstallColormap(ColormapPtr pmap)
 }
 
 static void
-vfbUninstallColormap(ColormapPtr pmap)
-{
-    ColormapPtr curpmap = GetInstalledColormap(pmap->pScreen);
-
-    if (pmap == curpmap) {
-        if (pmap->mid != pmap->pScreen->defColormap) {
-            dixLookupResourceByType((void **) &curpmap,
-                                    pmap->pScreen->defColormap,
-                                    RT_COLORMAP, serverClient,
-                                    DixInstallAccess);
-            (*pmap->pScreen->InstallColormap) (curpmap);
-        }
-    }
-}
-
-static void
 vfbStoreColors(ColormapPtr pmap, int ndef, xColorItem * pdefs)
 {
     XWDColor *pXWDCmap;
     int i;
 
-    if (pmap != GetInstalledColormap(pmap->pScreen)) {
+    if (pmap != GetInstalledmiColormap(pmap->pScreen)) {
         return;
     }
 
@@ -761,18 +725,10 @@ static Bool
 vfbCloseScreen(ScreenPtr pScreen)
 {
     vfbScreenInfoPtr pvfb = &vfbScreens[pScreen->myNum];
-    int i;
 
     pScreen->CloseScreen = pvfb->closeScreen;
 
     /*
-     * XXX probably lots of stuff to clean.  For now,
-     * clear installed colormaps so that server reset works correctly.
-     */
-    for (i = 0; i < screenInfo.numScreens; i++)
-        SetInstalledColormap(screenInfo.screens[i], NULL);
-
-    /*
      * fb overwrites miCloseScreen, so do this here
      */
     if (pScreen->devPrivate)
@@ -790,9 +746,6 @@ vfbScreenInit(ScreenPtr pScreen, int argc, char **argv)
     int ret;
     char *pbits;
 
-    if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))
-        return FALSE;
-
     if (dpix == 0)
         dpix = 100;
 
@@ -859,8 +812,6 @@ vfbScreenInit(ScreenPtr pScreen, int argc, char **argv)
         return FALSE;
 
     pScreen->InstallColormap = vfbInstallColormap;
-    pScreen->UninstallColormap = vfbUninstallColormap;
-    pScreen->ListInstalledColormaps = vfbListInstalledColormaps;
 
     pScreen->SaveScreen = vfbSaveScreen;
     pScreen->StoreColors = vfbStoreColors;
diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index 779ba6f7c..5b254bafa 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -571,25 +571,6 @@ xf86DriverlistFromCompile(void)
     return driverlist;
 }
 
-/*
- * xf86ConfigError --
- *      Print a READABLE ErrorMessage!!!  All information that is 
- *      available is printed.
- */
-static void
-_X_ATTRIBUTE_PRINTF(1, 2)
-xf86ConfigError(const char *msg, ...)
-{
-    va_list ap;
-
-    ErrorF("\nConfig Error:\n");
-    va_start(ap, msg);
-    VErrorF(msg, ap);
-    va_end(ap);
-    ErrorF("\n");
-    return;
-}
-
 static void
 configFiles(XF86ConfFilesPtr fileconf)
 {
@@ -779,7 +760,7 @@ static OptionInfoRec FlagOptions[] = {
      {0}, FALSE},
 };
 
-static Bool
+static void
 configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
 {
     XF86OptionPtr optp, tmp;
@@ -893,12 +874,10 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
         if ((s = xf86GetOptValString(FlagOptions, FLAG_LOG))) {
             if (!xf86NameCmp(s, "flush")) {
                 xf86Msg(X_CONFIG, "Flushing logfile enabled\n");
-                xf86Info.log = LogFlush;
                 LogSetParameter(XLOG_FLUSH, TRUE);
             }
             else if (!xf86NameCmp(s, "sync")) {
                 xf86Msg(X_CONFIG, "Syncing logfile enabled\n");
-                xf86Info.log = LogSync;
                 LogSetParameter(XLOG_FLUSH, TRUE);
                 LogSetParameter(XLOG_SYNC, TRUE);
             }
@@ -980,10 +959,8 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     XkbFreeRMLVOSet(&set, FALSE);
 
     xf86Info.useDefaultFontPath = TRUE;
-    xf86Info.useDefaultFontPathFrom = X_DEFAULT;
     if (xf86GetOptValBool(FlagOptions, FLAG_USE_DEFAULT_FONT_PATH, &value)) {
         xf86Info.useDefaultFontPath = value;
-        xf86Info.useDefaultFontPathFrom = X_CONFIG;
     }
 
 /* Make sure that timers don't overflow CARD32's after multiplying */
@@ -994,9 +971,8 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     if ((i >= 0) && (i < MAX_TIME_IN_MIN))
         ScreenSaverTime = defaultScreenSaverTime = i * MILLI_PER_MIN;
     else if (i != -1)
-        xf86ConfigError
-            ("BlankTime value %d outside legal range of 0 - %d minutes", i,
-             MAX_TIME_IN_MIN);
+        ErrorF("BlankTime value %d outside legal range of 0 - %d minutes\n",
+               i, MAX_TIME_IN_MIN);
 
 #ifdef DPMSExtension
     i = -1;
@@ -1004,25 +980,22 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     if ((i >= 0) && (i < MAX_TIME_IN_MIN))
         DPMSStandbyTime = i * MILLI_PER_MIN;
     else if (i != -1)
-        xf86ConfigError
-            ("StandbyTime value %d outside legal range of 0 - %d minutes", i,
-             MAX_TIME_IN_MIN);
+        ErrorF("StandbyTime value %d outside legal range of 0 - %d minutes\n",
+               i, MAX_TIME_IN_MIN);
     i = -1;
     xf86GetOptValInteger(FlagOptions, FLAG_DPMS_SUSPENDTIME, &i);
     if ((i >= 0) && (i < MAX_TIME_IN_MIN))
         DPMSSuspendTime = i * MILLI_PER_MIN;
     else if (i != -1)
-        xf86ConfigError
-            ("SuspendTime value %d outside legal range of 0 - %d minutes", i,
-             MAX_TIME_IN_MIN);
+        ErrorF("SuspendTime value %d outside legal range of 0 - %d minutes\n",
+               i, MAX_TIME_IN_MIN);
     i = -1;
     xf86GetOptValInteger(FlagOptions, FLAG_DPMS_OFFTIME, &i);
     if ((i >= 0) && (i < MAX_TIME_IN_MIN))
         DPMSOffTime = i * MILLI_PER_MIN;
     else if (i != -1)
-        xf86ConfigError
-            ("OffTime value %d outside legal range of 0 - %d minutes", i,
-             MAX_TIME_IN_MIN);
+        ErrorF("OffTime value %d outside legal range of 0 - %d minutes\n",
+               i, MAX_TIME_IN_MIN);
 #endif
 
     i = -1;
@@ -1037,8 +1010,8 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     case -1:
         break;
     default:
-        xf86ConfigError("Pixmap option's value (%d) must be 24 or 32\n", i);
-        return FALSE;
+        ErrorF("Pixmap option's value (%d) must be 24 or 32\n", i);
+        break;
     }
     if (xf86Pix24 != Pix24DontCare) {
         xf86Info.pixmap24 = xf86Pix24;
@@ -1073,8 +1046,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
         xf86Info.dri2From = X_CONFIG;
     }
 #endif
-
-    return TRUE;
 }
 
 Bool
@@ -2049,8 +2020,8 @@ configMonitor(MonPtr monitorp, XF86ConfMonitorPtr conf_monitor)
         badgamma = monitorp->gamma.blue;
     }
     if (badgamma > GAMMA_ZERO) {
-        xf86ConfigError("Gamma value %.f is out of range (%.2f - %.1f)\n",
-                        badgamma, GAMMA_MIN, GAMMA_MAX);
+        ErrorF("Gamma value %.f is out of range (%.2f - %.1f)\n", badgamma,
+               GAMMA_MIN, GAMMA_MAX);
         return FALSE;
     }
 
@@ -2109,8 +2080,7 @@ configDisplay(DispPtr displayp, XF86ConfDisplayPtr conf_display)
     if (conf_display->disp_visual) {
         displayp->defaultVisual = lookupVisual(conf_display->disp_visual);
         if (displayp->defaultVisual == -1) {
-            xf86ConfigError("Invalid visual name: \"%s\"",
-                            conf_display->disp_visual);
+            ErrorF("Invalid visual name: \"%s\"\n", conf_display->disp_visual);
             return FALSE;
         }
     }
@@ -2168,7 +2138,6 @@ configDevice(GDevPtr devicep, XF86ConfDevicePtr conf_device, Bool active)
     devicep->IOBase = conf_device->dev_io_base;
     devicep->clockchip = conf_device->dev_clockchip;
     devicep->busID = conf_device->dev_busid;
-    devicep->textClockFreq = conf_device->dev_textclockfreq;
     devicep->chipID = conf_device->dev_chipid;
     devicep->chipRev = conf_device->dev_chiprev;
     devicep->options = conf_device->dev_option_lst;
@@ -2503,11 +2472,7 @@ xf86HandleConfigFile(Bool autoconfig)
     }
 #endif
     /* Now process everything else */
-    if (!configServerFlags(xf86configptr->conf_flags, xf86ConfigLayout.options)) {
-        ErrorF("Problem when converting the config data structures\n");
-        return CONFIG_PARSE_ERROR;
-    }
-
+    configServerFlags(xf86configptr->conf_flags, xf86ConfigLayout.options);
     configFiles(xf86configptr->conf_files);
     configExtensions(xf86configptr->conf_extensions);
 #ifdef XF86DRI
diff --git a/xorg-server/hw/xfree86/common/xf86Configure.c b/xorg-server/hw/xfree86/common/xf86Configure.c
index 967bfbc93..8dbca3a1e 100644
--- a/xorg-server/hw/xfree86/common/xf86Configure.c
+++ b/xorg-server/hw/xfree86/common/xf86Configure.c
@@ -267,7 +267,6 @@ configureDeviceSection(int screennum)
     for (i = 0; (i < MAXDACSPEEDS) && (i < CONF_MAXDACSPEEDS); i++)
         ptr->dev_dacSpeeds[i] = DevToConfig[screennum].GDev.dacSpeeds[i];
     ptr->dev_videoram = DevToConfig[screennum].GDev.videoRam;
-    ptr->dev_textclockfreq = DevToConfig[screennum].GDev.textClockFreq;
     ptr->dev_bios_base = DevToConfig[screennum].GDev.BiosBase;
     ptr->dev_mem_base = DevToConfig[screennum].GDev.MemBase;
     ptr->dev_io_base = DevToConfig[screennum].GDev.IOBase;
diff --git a/xorg-server/hw/xfree86/common/xf86Globals.c b/xorg-server/hw/xfree86/common/xf86Globals.c
index 984c39bca..93a35b80e 100644
--- a/xorg-server/hw/xfree86/common/xf86Globals.c
+++ b/xorg-server/hw/xfree86/common/xf86Globals.c
@@ -120,7 +120,6 @@ xf86InfoRec xf86Info = {
     .pixmap24 = Pix24DontCare,
     .pix24From = X_DEFAULT,
     .pmFlag = TRUE,
-    .log = LogNone,
     .disableRandR = FALSE,
     .randRFrom = X_DEFAULT,
 #if defined(CONFIG_HAL) || defined(CONFIG_UDEV) || defined(CONFIG_WSCONS)
diff --git a/xorg-server/hw/xfree86/common/xf86Init.c b/xorg-server/hw/xfree86/common/xf86Init.c
index b197c1c38..017dcb6bb 100644
--- a/xorg-server/hw/xfree86/common/xf86Init.c
+++ b/xorg-server/hw/xfree86/common/xf86Init.c
@@ -233,12 +233,6 @@ xf86PrintBanner(void)
                    "\tto make sure that you have the latest version.\n");
 }
 
-static void
-xf86PrintMarkers(void)
-{
-    LogPrintMarkers();
-}
-
 Bool
 xf86PrivsElevated(void)
 {
@@ -314,14 +308,6 @@ xf86CreateRootWindow(WindowPtr pWin)
 
     DebugF("xf86CreateRootWindow(%p)\n", pWin);
 
-    if (pScreen->CreateWindow != xf86CreateRootWindow) {
-        /* Can't find hook we are hung on */
-        xf86DrvMsg(pScreen->myNum, X_WARNING /* X_ERROR */ ,
-                   "xf86CreateRootWindow %p called when not in pScreen->CreateWindow %p n",
-                   (void *) xf86CreateRootWindow,
-                   (void *) pScreen->CreateWindow);
-    }
-
     /* Unhook this function ... */
     pScreen->CreateWindow = create_window;
     dixSetPrivate(&pScreen->devPrivates, xf86CreateRootWindowKey, NULL);
@@ -349,15 +335,8 @@ xf86CreateRootWindow(WindowPtr pWin)
             ret &= (err == Success);
 
         }
-        else {
-            xf86Msg(X_ERROR, "xf86CreateRootWindow unexpectedly called with "
-                    "non-root window %p (parent %p)\n",
-                    (void *) pWin, (void *) pWin->parent);
-            ret = FALSE;
-        }
     }
 
-    DebugF("xf86CreateRootWindow() returns %d\n", ret);
     return ret;
 }
 
@@ -421,7 +400,7 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
             xf86ServerName = argv[0];
 
         xf86PrintBanner();
-        xf86PrintMarkers();
+        LogPrintMarkers();
         if (xf86LogFile) {
             time_t t;
             const char *ct;
diff --git a/xorg-server/hw/xfree86/common/xf86Privstr.h b/xorg-server/hw/xfree86/common/xf86Privstr.h
index 410ef17ac..cffa14d01 100644
--- a/xorg-server/hw/xfree86/common/xf86Privstr.h
+++ b/xorg-server/hw/xfree86/common/xf86Privstr.h
@@ -37,12 +37,6 @@
 #include "xf86str.h"
 
 typedef enum {
-    LogNone,
-    LogFlush,
-    LogSync
-} Log;
-
-typedef enum {
     XF86_GlxVisualsMinimal,
     XF86_GlxVisualsTypical,
     XF86_GlxVisualsAll,
@@ -91,7 +85,6 @@ typedef struct {
     Pix24Flags pixmap24;
     MessageType pix24From;
     Bool pmFlag;
-    Log log;
     Bool disableRandR;
     MessageType randRFrom;
     Bool aiglx;
@@ -100,7 +93,6 @@ typedef struct {
     MessageType glxVisualsFrom;
 
     Bool useDefaultFontPath;
-    MessageType useDefaultFontPathFrom;
     Bool ignoreABI;
 
     Bool forceInputDevices;     /* force xorg.conf or built-in input devices */
diff --git a/xorg-server/hw/xfree86/common/xf86cmap.c b/xorg-server/hw/xfree86/common/xf86cmap.c
index 3f9c88035..c4bae56ad 100644
--- a/xorg-server/hw/xfree86/common/xf86cmap.c
+++ b/xorg-server/hw/xfree86/common/xf86cmap.c
@@ -74,7 +74,6 @@ typedef struct _CMapLink {
 } CMapLink, *CMapLinkPtr;
 
 typedef struct {
-    ScrnInfoPtr pScrn;
     CloseScreenProcPtr CloseScreen;
     CreateColormapProcPtr CreateColormap;
     DestroyColormapProcPtr DestroyColormap;
@@ -123,7 +122,7 @@ static int CMapSetDGAMode(ScrnInfoPtr, int, DGADevicePtr);
 #endif
 static int CMapChangeGamma(ScrnInfoPtr, Gamma);
 
-static void ComputeGamma(CMapScreenPtr);
+static void ComputeGamma(ScrnInfoPtr, CMapScreenPtr);
 static Bool CMapAllocateColormapPrivate(ColormapPtr);
 static void CMapRefreshColors(ColormapPtr, int, int *);
 static void CMapSetOverscan(ColormapPtr, int, int *);
@@ -194,7 +193,6 @@ xf86HandleColormaps(ScreenPtr pScreen,
     pScreen->InstallColormap = CMapInstallColormap;
     pScreen->StoreColors = CMapStoreColors;
 
-    pScreenPriv->pScrn = pScrn;
     pScrn->LoadPalette = loadPalette;
     pScrn->SetOverscan = setOverscan;
     pScreenPriv->maxColors = maxColors;
@@ -221,7 +219,7 @@ xf86HandleColormaps(ScreenPtr pScreen,
 #endif
     pScrn->ChangeGamma = CMapChangeGamma;
 
-    ComputeGamma(pScreenPriv);
+    ComputeGamma(pScrn, pScreenPriv);
 
     /* get the default map */
     dixLookupResourceByType((void **) &pDefMap, pScreen->defColormap,
@@ -660,8 +658,7 @@ CMapRefreshColors(ColormapPtr pmap, int defs, int *indices)
     }
 
     if (LOAD_PALETTE(pmap))
-        (*pScrn->LoadPalette) (pScreenPriv->pScrn, defs, indices,
-                               colors, pmap->pVisual);
+        (*pScrn->LoadPalette) (pScrn, defs, indices, colors, pmap->pVisual);
 
     if (pScrn->SetOverscan)
         CMapSetOverscan(pmap, defs, indices);
@@ -822,7 +819,7 @@ CMapSetOverscan(ColormapPtr pmap, int defs, int *indices)
 #ifdef DEBUGOVERSCAN
             ErrorF("SetOverscan() called from CmapSetOverscan\n");
 #endif
-            pScrn->SetOverscan(pScreenPriv->pScrn, overscan);
+            pScrn->SetOverscan(pScrn, overscan);
         }
     }
 }
@@ -851,7 +848,7 @@ CMapUnwrapScreen(ScreenPtr pScreen)
 }
 
 static void
-ComputeGamma(CMapScreenPtr priv)
+ComputeGamma(ScrnInfoPtr pScrn, CMapScreenPtr priv)
 {
     int elements = priv->gammaElements - 1;
     double RedGamma, GreenGamma, BlueGamma;
@@ -859,28 +856,25 @@ ComputeGamma(CMapScreenPtr priv)
 
 #ifndef DONT_CHECK_GAMMA
     /* This check is to catch drivers that are not initialising pScrn->gamma */
-    if (priv->pScrn->gamma.red < GAMMA_MIN ||
-        priv->pScrn->gamma.red > GAMMA_MAX ||
-        priv->pScrn->gamma.green < GAMMA_MIN ||
-        priv->pScrn->gamma.green > GAMMA_MAX ||
-        priv->pScrn->gamma.blue < GAMMA_MIN ||
-        priv->pScrn->gamma.blue > GAMMA_MAX) {
-
-        xf86DrvMsgVerb(priv->pScrn->scrnIndex, X_WARNING, 0,
+    if (pScrn->gamma.red < GAMMA_MIN || pScrn->gamma.red > GAMMA_MAX ||
+        pScrn->gamma.green < GAMMA_MIN || pScrn->gamma.green > GAMMA_MAX ||
+        pScrn->gamma.blue < GAMMA_MIN || pScrn->gamma.blue > GAMMA_MAX) {
+
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_WARNING, 0,
                        "The %s driver didn't call xf86SetGamma() to initialise\n"
-                       "\tthe gamma values.\n", priv->pScrn->driverName);
-        xf86DrvMsgVerb(priv->pScrn->scrnIndex, X_WARNING, 0,
+                       "\tthe gamma values.\n", pScrn->driverName);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_WARNING, 0,
                        "PLEASE FIX THE `%s' DRIVER!\n",
-                       priv->pScrn->driverName);
-        priv->pScrn->gamma.red = 1.0;
-        priv->pScrn->gamma.green = 1.0;
-        priv->pScrn->gamma.blue = 1.0;
+                       pScrn->driverName);
+        pScrn->gamma.red = 1.0;
+        pScrn->gamma.green = 1.0;
+        pScrn->gamma.blue = 1.0;
     }
 #endif
 
-    RedGamma = 1.0 / (double) priv->pScrn->gamma.red;
-    GreenGamma = 1.0 / (double) priv->pScrn->gamma.green;
-    BlueGamma = 1.0 / (double) priv->pScrn->gamma.blue;
+    RedGamma = 1.0 / (double) pScrn->gamma.red;
+    GreenGamma = 1.0 / (double) pScrn->gamma.green;
+    BlueGamma = 1.0 / (double) pScrn->gamma.blue;
 
     for (i = 0; i <= elements; i++) {
         if (RedGamma == 1.0)
@@ -933,7 +927,7 @@ CMapChangeGamma(ScrnInfoPtr pScrn, Gamma gamma)
     pScrn->gamma.green = gamma.green;
     pScrn->gamma.blue = gamma.blue;
 
-    ComputeGamma(pScreenPriv);
+    ComputeGamma(pScrn, pScreenPriv);
 
     /* mark all colormaps on this screen */
     pLink = pScreenPriv->maps;
diff --git a/xorg-server/hw/xfree86/common/xf86str.h b/xorg-server/hw/xfree86/common/xf86str.h
index a81e88614..9ad1b9014 100644
--- a/xorg-server/hw/xfree86/common/xf86str.h
+++ b/xorg-server/hw/xfree86/common/xf86str.h
@@ -403,7 +403,6 @@ typedef struct {
     Bool active;
     Bool inUse;
     int videoRam;
-    int textClockFreq;
     unsigned long BiosBase;     /* Base address of video BIOS */
     unsigned long MemBase;      /* Frame buffer base address */
     unsigned long IOBase;
@@ -753,7 +752,6 @@ typedef struct _ScrnInfoRec {
     unsigned long memPhysBase;  /* Physical address of FB */
     unsigned long fbOffset;     /* Offset of FB in the above */
     int memClk;                 /* memory clock */
-    int textClockFreq;          /* clock of text mode */
     Bool flipPixels;            /* swap default black/white */
     void *options;
 
diff --git a/xorg-server/hw/xfree86/common/xf86xv.c b/xorg-server/hw/xfree86/common/xf86xv.c
index d342bdecc..5ef5de19c 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.c
+++ b/xorg-server/hw/xfree86/common/xf86xv.c
@@ -84,7 +84,7 @@ static int xf86XVQueryImageAttributes(XvPortPtr, XvImagePtr,
 /* ScreenRec fields */
 
 static Bool xf86XVDestroyWindow(WindowPtr pWin);
-static void xf86XVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2);
+static void xf86XVWindowExposures(WindowPtr pWin, RegionPtr r1);
 static void xf86XVPostValidateTree(WindowPtr pWin, WindowPtr pLayerWin,
                                    VTKind kind);
 static void xf86XVClipNotify(WindowPtr pWin, int dx, int dy);
@@ -1048,7 +1048,7 @@ xf86XVPostValidateTree(WindowPtr pWin, WindowPtr pLayerWin, VTKind kind)
 }
 
 static void
-xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
+xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1)
 {
     ScreenPtr pScreen = pWin->drawable.pScreen;
     XF86XVScreenPtr ScreenPriv = GET_XF86XV_SCREEN(pScreen);
@@ -1059,7 +1059,7 @@ xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
     AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
 
     pScreen->WindowExposures = ScreenPriv->WindowExposures;
-    (*pScreen->WindowExposures) (pWin, reg1, reg2);
+    (*pScreen->WindowExposures) (pWin, reg1);
     pScreen->WindowExposures = xf86XVWindowExposures;
 
     /* filter out XClearWindow/Area */
@@ -1117,10 +1117,6 @@ xf86XVClipNotify(WindowPtr pWin, int dx, int dy)
 
         pPriv->pCompositeClip = NULL;
 
-        if (pPriv->AdaptorRec->ClipNotify)
-            (*pPriv->AdaptorRec->ClipNotify) (pPriv->pScrn, pPriv->DevPriv.ptr,
-                                              pWin, dx, dy);
-
         pPriv->clipChanged = TRUE;
 
         if (ScreenPriv->PostValidateTree == PostValidateTreeUndefined) {
diff --git a/xorg-server/hw/xfree86/common/xf86xv.h b/xorg-server/hw/xfree86/common/xf86xv.h
index c6455d703..6f8662c04 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.h
+++ b/xorg-server/hw/xfree86/common/xf86xv.h
@@ -95,8 +95,6 @@ typedef int (*QueryImageAttributesFuncPtr) (ScrnInfoPtr pScrn, int image,
                                             unsigned short *width,
                                             unsigned short *height,
                                             int *pitches, int *offsets);
-typedef void (*ClipNotifyFuncPtr) (ScrnInfoPtr pScrn, void *data,
-                                   WindowPtr window, int dx, int dy);
 
 typedef enum {
     XV_OFF,
@@ -145,7 +143,6 @@ typedef struct {
     PutImageFuncPtr PutImage;
     ReputImageFuncPtr ReputImage;       /* image/still */
     QueryImageAttributesFuncPtr QueryImageAttributes;
-    ClipNotifyFuncPtr ClipNotify;
 } XF86VideoAdaptorRec, *XF86VideoAdaptorPtr;
 
 typedef struct {
diff --git a/xorg-server/hw/xfree86/common/xf86xvpriv.h b/xorg-server/hw/xfree86/common/xf86xvpriv.h
index c0dff16d5..8fb22e60e 100644
--- a/xorg-server/hw/xfree86/common/xf86xvpriv.h
+++ b/xorg-server/hw/xfree86/common/xf86xvpriv.h
@@ -61,7 +61,6 @@ typedef struct {
     PutImageFuncPtr PutImage;
     ReputImageFuncPtr ReputImage;
     QueryImageAttributesFuncPtr QueryImageAttributes;
-    ClipNotifyFuncPtr ClipNotify;
 } XvAdaptorRecPrivate, *XvAdaptorRecPrivatePtr;
 
 typedef struct {
diff --git a/xorg-server/hw/xfree86/ddc/ddc.c b/xorg-server/hw/xfree86/ddc/ddc.c
index 04d1a09c5..15e4beb54 100644
--- a/xorg-server/hw/xfree86/ddc/ddc.c
+++ b/xorg-server/hw/xfree86/ddc/ddc.c
@@ -468,61 +468,3 @@ xf86DoEDID_DDC2(ScrnInfoPtr pScrn, I2CBusPtr pBus)
 {
     return xf86DoEEDID(pScrn, pBus, FALSE);
 }
-
-/* XXX write me */
-static void *
-DDC2ReadDisplayID(void)
-{
-    return FALSE;
-}
-
-/**
- * Attempts to probe the monitor for DisplayID information, if NoDDC and
- * NoDDC2 are unset.  DisplayID blocks are interpreted and the results
- * returned in an xf86MonPtr.
- *
- * This function does not affect the list of modes used by drivers -- it is up
- * to the driver to decide policy on what to do with DisplayID information.
- *
- * @return pointer to a new xf86MonPtr containing the DisplayID information.
- * @return NULL if no monitor attached or failure to interpret the DisplayID.
- */
-xf86MonPtr
-xf86DoDisplayID(ScrnInfoPtr pScrn, I2CBusPtr pBus)
-{
-    unsigned char *did = NULL;
-    xf86MonPtr tmp = NULL;
-    I2CDevPtr dev = NULL;
-
-    /* Default DDC and DDC2 to enabled. */
-    Bool noddc = FALSE, noddc2 = FALSE;
-    OptionInfoPtr options;
-
-    options = malloc(sizeof(DDCOptions));
-    if (!options)
-        return NULL;
-    memcpy(options, DDCOptions, sizeof(DDCOptions));
-    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
-
-    xf86GetOptValBool(options, DDCOPT_NODDC, &noddc);
-    xf86GetOptValBool(options, DDCOPT_NODDC2, &noddc2);
-    free(options);
-
-    if (noddc || noddc2)
-        return NULL;
-
-    if (!(dev = DDC2Init(pBus)))
-        return NULL;
-
-    if ((did = DDC2ReadDisplayID())) {
-        tmp = calloc(1, sizeof(*tmp));
-        if (!tmp)
-            return NULL;
-
-        tmp->scrnIndex = pScrn->scrnIndex;
-        tmp->flags |= MONITOR_DISPLAYID;
-        tmp->rawData = did;
-    }
-
-    return tmp;
-}
diff --git a/xorg-server/hw/xfree86/ddc/xf86DDC.h b/xorg-server/hw/xfree86/ddc/xf86DDC.h
index de8e71831..727813f07 100644
--- a/xorg-server/hw/xfree86/ddc/xf86DDC.h
+++ b/xorg-server/hw/xfree86/ddc/xf86DDC.h
@@ -48,11 +48,6 @@ extern _X_EXPORT Bool xf86SetDDCproperties(ScrnInfoPtr pScreen, xf86MonPtr DDC);
 extern _X_EXPORT Bool
  xf86MonitorIsHDMI(xf86MonPtr mon);
 
-extern _X_EXPORT xf86MonPtr xf86DoDisplayID(ScrnInfoPtr pScrn, I2CBusPtr pBus);
-
-extern _X_EXPORT void
- xf86DisplayIDMonitorSet(int scrnIndex, MonPtr mon, xf86MonPtr DDC);
-
 extern _X_EXPORT DisplayModePtr
 FindDMTMode(int hsize, int vsize, int refresh, Bool rb);
 
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/modinit.h b/xorg-server/hw/xfree86/dixmods/extmod/modinit.h
deleted file mode 100644
index 4c9b6e3cc..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/modinit.h
+++ /dev/null
@@ -1,80 +0,0 @@
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/extensions/shapeproto.h>
-
-#ifdef XTEST
-extern void XTestExtensionInit(void);
-#include <X11/extensions/xtestproto.h>
-#endif
-
-#if 1
-extern void XTestExtension1Init(void);
-#endif
-
-#if 1
-extern void XCMiscExtensionInit(void);
-#endif
-
-#ifdef SCREENSAVER
-extern void ScreenSaverExtensionInit(void);
-#include <X11/extensions/saver.h>
-#endif
-
-#ifdef XF86VIDMODE
-extern void XFree86VidModeExtensionInit(void);
-#include <X11/extensions/xf86vmproto.h>
-#endif
-
-#ifdef XFreeXDGA
-extern void XFree86DGAExtensionInit(void);
-extern void XFree86DGARegister(void);
-#include <X11/extensions/xf86dgaproto.h>
-#endif
-
-#ifdef DPMSExtension
-extern void DPMSExtensionInit(void);
-#include <X11/extensions/dpmsconst.h>
-#endif
-
-#ifdef XV
-extern void XvExtensionInit(void);
-extern void XvMCExtensionInit(void);
-extern void XvRegister(void);
-#include <X11/extensions/Xv.h>
-#include <X11/extensions/XvMC.h>
-#endif
-
-#ifdef RES
-extern void ResExtensionInit(void);
-#include <X11/extensions/XResproto.h>
-#endif
-
-#ifdef SHM
-#include <X11/extensions/shmproto.h>
-extern void ShmExtensionInit(void);
-extern void ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
-#endif
-
-#ifdef XSELINUX
-extern void SELinuxExtensionInit(void);
-#include "xselinux.h"
-#endif
-
-#ifdef XEVIE
-extern void XevieExtensionInit(void);
-#endif
-
-#if 1
-extern void SecurityExtensionInit(void);
-#endif
-
-#if 1
-extern void PanoramiXExtensionInit(void);
-#endif
-
-#if 1
-extern void XkbExtensionInit(void);
-#endif
diff --git a/xorg-server/hw/xfree86/dri/dri.c b/xorg-server/hw/xfree86/dri/dri.c
index 3f2f6a9b3..5077c7c6d 100644
--- a/xorg-server/hw/xfree86/dri/dri.c
+++ b/xorg-server/hw/xfree86/dri/dri.c
@@ -1828,7 +1828,7 @@ DRIGetContextStore(DRIContextPrivPtr context)
 }
 
 void
-DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
+DRIWindowExposures(WindowPtr pWin, RegionPtr prgn)
 {
     ScreenPtr pScreen = pWin->drawable.pScreen;
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@@ -1846,7 +1846,7 @@ DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
         pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures;
 
         /* call lower layers */
-        (*pScreen->WindowExposures) (pWin, prgn, bsreg);
+        (*pScreen->WindowExposures) (pWin, prgn);
 
         /* rewrap */
         pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;
diff --git a/xorg-server/hw/xfree86/dri/dri.h b/xorg-server/hw/xfree86/dri/dri.h
index dec688582..1ce0970cd 100644
--- a/xorg-server/hw/xfree86/dri/dri.h
+++ b/xorg-server/hw/xfree86/dri/dri.h
@@ -280,8 +280,7 @@ extern _X_EXPORT void DRISwapContext(int drmFD, void *oldctx, void *newctx);
 
 extern _X_EXPORT void *DRIGetContextStore(DRIContextPrivPtr context);
 
-extern _X_EXPORT void DRIWindowExposures(WindowPtr pWin,
-                                         RegionPtr prgn, RegionPtr bsreg);
+extern _X_EXPORT void DRIWindowExposures(WindowPtr pWin, RegionPtr prgn);
 
 extern _X_EXPORT Bool DRIDestroyWindow(WindowPtr pWin);
 
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/Makefile.am b/xorg-server/hw/xfree86/drivers/modesetting/Makefile.am
index ca3279e23..e6834e283 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/Makefile.am
+++ b/xorg-server/hw/xfree86/drivers/modesetting/Makefile.am
@@ -28,6 +28,7 @@ AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS) $(LIBDRM_CFLAGS) $(UDEV_CFLAGS) $(CWARN
 
 AM_CPPFLAGS = \
 	$(XORG_INCS) \
+	-I$(top_srcdir)/glamor \
 	-I$(srcdir)/../../ddc \
 	-I$(srcdir)/../../i2c \
 	-I$(srcdir)/../../modes \
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/driver.c b/xorg-server/hw/xfree86/drivers/modesetting/driver.c
index adfb69c9f..c62147a0f 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/driver.c
+++ b/xorg-server/hw/xfree86/drivers/modesetting/driver.c
@@ -61,13 +61,18 @@
 
 #include "driver.h"
 
+#ifdef GLAMOR
+#define GLAMOR_FOR_XORG 1
+#include "glamor.h"
+#endif
+
 static void AdjustFrame(ScrnInfoPtr pScrn, int x, int y);
 static Bool CloseScreen(ScreenPtr pScreen);
 static Bool EnterVT(ScrnInfoPtr pScrn);
 static void Identify(int flags);
 static const OptionInfoRec *AvailableOptions(int chipid, int busid);
-static ModeStatus ValidMode(ScrnInfoPtr pScrn, DisplayModePtr mode, Bool verbose,
-			    int flags);
+static ModeStatus ValidMode(ScrnInfoPtr pScrn, DisplayModePtr mode,
+                            Bool verbose, int flags);
 static void FreeScreen(ScrnInfoPtr pScrn);
 static void LeaveVT(ScrnInfoPtr pScrn);
 static Bool SwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode);
@@ -76,26 +81,25 @@ static Bool PreInit(ScrnInfoPtr pScrn, int flags);
 
 static Bool Probe(DriverPtr drv, int flags);
 static Bool ms_pci_probe(DriverPtr driver,
-			 int entity_num, struct pci_device *device,
-			 intptr_t match_data);
-static Bool ms_driver_func(ScrnInfoPtr scrn, xorgDriverFuncOp op,
-			   void *data);
+                         int entity_num, struct pci_device *device,
+                         intptr_t match_data);
+static Bool ms_driver_func(ScrnInfoPtr scrn, xorgDriverFuncOp op, void *data);
 
 #ifdef XSERVER_LIBPCIACCESS
 static const struct pci_id_match ms_device_match[] = {
     {
-	PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY,
-	0x00030000, 0x00ff0000, 0
-    },
+     PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY,
+     0x00030000, 0x00ff0000, 0},
 
-    { 0, 0, 0 },
+    {0, 0, 0},
 };
 #endif
 
 #ifdef XSERVER_PLATFORM_BUS
 static Bool ms_platform_probe(DriverPtr driver,
-                          int entity_num, int flags, struct xf86_platform_device *device,
-			  intptr_t match_data);
+                              int entity_num, int flags,
+                              struct xf86_platform_device *device,
+                              intptr_t match_data);
 #endif
 
 _X_EXPORT DriverRec modesetting = {
@@ -115,21 +119,22 @@ _X_EXPORT DriverRec modesetting = {
 };
 
 static SymTabRec Chipsets[] = {
-    {0, "kms" },
+    {0, "kms"},
     {-1, NULL}
 };
 
-typedef enum
-{
+typedef enum {
     OPTION_SW_CURSOR,
     OPTION_DEVICE_PATH,
     OPTION_SHADOW_FB,
+    OPTION_ACCEL_METHOD,
 } modesettingOpts;
 
 static const OptionInfoRec Options[] = {
     {OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE},
-    {OPTION_DEVICE_PATH, "kmsdev", OPTV_STRING, {0}, FALSE },
-    {OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE },
+    {OPTION_DEVICE_PATH, "kmsdev", OPTV_STRING, {0}, FALSE},
+    {OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE},
+    {OPTION_ACCEL_METHOD, "AccelMethod", OPTV_STRING, {0}, FALSE},
     {-1, NULL, OPTV_NONE, {0}, FALSE}
 };
 
@@ -155,25 +160,26 @@ static XF86ModuleVersionInfo VersRec = {
 _X_EXPORT XF86ModuleData modesettingModuleData = { &VersRec, Setup, NULL };
 
 static void *
-Setup(void * module, void * opts, int *errmaj, int *errmin)
+Setup(void *module, void *opts, int *errmaj, int *errmin)
 {
     static Bool setupDone = 0;
 
     /* This module should be loaded only once, but check to be sure.
      */
     if (!setupDone) {
-	setupDone = 1;
-	xf86AddDriver(&modesetting, module, HaveDriverFuncs);
-
-	/*
-	 * The return value must be non-NULL on success even though there
-	 * is no TearDownProc.
-	 */
-	return (void *) 1;
-    } else {
-	if (errmaj)
-	    *errmaj = LDR_ONCEONLY;
-	return NULL;
+        setupDone = 1;
+        xf86AddDriver(&modesetting, module, HaveDriverFuncs);
+
+        /*
+         * The return value must be non-NULL on success even though there
+         * is no TearDownProc.
+         */
+        return (void *) 1;
+    }
+    else {
+        if (errmaj)
+            *errmaj = LDR_ONCEONLY;
+        return NULL;
     }
 }
 
@@ -181,28 +187,31 @@ static void
 Identify(int flags)
 {
     xf86PrintChipsets("modesetting", "Driver for Modesetting Kernel Drivers",
-		      Chipsets);
+                      Chipsets);
 }
 
-static int open_hw(const char *dev)
+static int
+open_hw(const char *dev)
 {
     int fd;
+
     if (dev)
-	fd = open(dev, O_RDWR, 0);
+        fd = open(dev, O_RDWR, 0);
     else {
-	dev = getenv("KMSDEVICE");
-	if ((NULL == dev) || ((fd = open(dev, O_RDWR, 0)) == -1)) {
-	    dev = "/dev/dri/card0";
-	    fd = open(dev,O_RDWR, 0);
-	}
+        dev = getenv("KMSDEVICE");
+        if ((NULL == dev) || ((fd = open(dev, O_RDWR, 0)) == -1)) {
+            dev = "/dev/dri/card0";
+            fd = open(dev, O_RDWR, 0);
+        }
     }
     if (fd == -1)
-	xf86DrvMsg(-1, X_ERROR,"open %s: %s\n", dev, strerror(errno));
+        xf86DrvMsg(-1, X_ERROR, "open %s: %s\n", dev, strerror(errno));
 
     return fd;
 }
 
-static int check_outputs(int fd)
+static int
+check_outputs(int fd)
 {
     drmModeResPtr res = drmModeGetResources(fd);
     int ret;
@@ -214,7 +223,8 @@ static int check_outputs(int fd)
     return ret;
 }
 
-static Bool probe_hw(const char *dev, struct xf86_platform_device *platform_dev)
+static Bool
+probe_hw(const char *dev, struct xf86_platform_device *platform_dev)
 {
     int fd;
 
@@ -230,6 +240,7 @@ static Bool probe_hw(const char *dev, struct xf86_platform_device *platform_dev)
     fd = open_hw(dev);
     if (fd != -1) {
         int ret = check_outputs(fd);
+
         close(fd);
         return ret;
     }
@@ -248,15 +259,15 @@ ms_DRICreatePCIBusID(const struct pci_device *dev)
     return busID;
 }
 
-
-static Bool probe_hw_pci(const char *dev, struct pci_device *pdev)
+static Bool
+probe_hw_pci(const char *dev, struct pci_device *pdev)
 {
     int ret = FALSE, fd = open_hw(dev);
     char *id, *devid;
     drmSetVersion sv;
 
     if (fd == -1)
-	return FALSE;
+        return FALSE;
 
     sv.drm_di_major = 1;
     sv.drm_di_minor = 4;
@@ -267,7 +278,6 @@ static Bool probe_hw_pci(const char *dev, struct pci_device *pdev)
         return FALSE;
     }
 
-
     id = drmGetBusid(fd);
     devid = ms_DRICreatePCIBusID(pdev);
 
@@ -279,6 +289,7 @@ static Bool probe_hw_pci(const char *dev, struct pci_device *pdev)
     free(devid);
     return ret;
 }
+
 static const OptionInfoRec *
 AvailableOptions(int chipid, int busid)
 {
@@ -289,55 +300,63 @@ static Bool
 ms_driver_func(ScrnInfoPtr scrn, xorgDriverFuncOp op, void *data)
 {
     xorgHWFlags *flag;
-    
+
     switch (op) {
-	case GET_REQUIRED_HW_INTERFACES:
-	    flag = (CARD32 *)data;
-	    (*flag) = 0;
-	    return TRUE;
-        case SUPPORTS_SERVER_FDS:
-            return TRUE;
-	default:
-	    return FALSE;
+    case GET_REQUIRED_HW_INTERFACES:
+        flag = (CARD32 *) data;
+        (*flag) = 0;
+        return TRUE;
+    case SUPPORTS_SERVER_FDS:
+        return TRUE;
+    default:
+        return FALSE;
     }
 }
 
+static void
+ms_setup_scrn_hooks(ScrnInfoPtr scrn)
+{
+    scrn->driverVersion = 1;
+    scrn->driverName = "modesetting";
+    scrn->name = "modeset";
+
+    scrn->Probe = NULL;
+    scrn->PreInit = PreInit;
+    scrn->ScreenInit = ScreenInit;
+    scrn->SwitchMode = SwitchMode;
+    scrn->AdjustFrame = AdjustFrame;
+    scrn->EnterVT = EnterVT;
+    scrn->LeaveVT = LeaveVT;
+    scrn->FreeScreen = FreeScreen;
+    scrn->ValidMode = ValidMode;
+}
+
 #if XSERVER_LIBPCIACCESS
 static Bool
 ms_pci_probe(DriverPtr driver,
-	     int entity_num, struct pci_device *dev, intptr_t match_data)
+             int entity_num, struct pci_device *dev, intptr_t match_data)
 {
     ScrnInfoPtr scrn = NULL;
 
     scrn = xf86ConfigPciEntity(scrn, 0, entity_num, NULL,
-			       NULL, NULL, NULL, NULL, NULL);
+                               NULL, NULL, NULL, NULL, NULL);
     if (scrn) {
-	const char *devpath;
-	GDevPtr devSection = xf86GetDevFromEntity(scrn->entityList[0],
-						  scrn->entityInstanceList[0]);
-
-	devpath = xf86FindOptionValue(devSection->options, "kmsdev");
-	if (probe_hw_pci(devpath, dev)) {
-	    scrn->driverVersion = 1;
-	    scrn->driverName = "modesetting";
-	    scrn->name = "modeset";
-	    scrn->Probe = NULL;
-	    scrn->PreInit = PreInit;
-	    scrn->ScreenInit = ScreenInit;
-	    scrn->SwitchMode = SwitchMode;
-	    scrn->AdjustFrame = AdjustFrame;
-	    scrn->EnterVT = EnterVT;
-	    scrn->LeaveVT = LeaveVT;
-	    scrn->FreeScreen = FreeScreen;
-	    scrn->ValidMode = ValidMode;
-
-	    xf86DrvMsg(scrn->scrnIndex, X_CONFIG,
-		       "claimed PCI slot %d@%d:%d:%d\n", 
-		       dev->bus, dev->domain, dev->dev, dev->func);
-	    xf86DrvMsg(scrn->scrnIndex, X_INFO,
-		       "using %s\n", devpath ? devpath : "default device");
-	} else
-	    scrn = NULL;
+        const char *devpath;
+        GDevPtr devSection = xf86GetDevFromEntity(scrn->entityList[0],
+                                                  scrn->entityInstanceList[0]);
+
+        devpath = xf86FindOptionValue(devSection->options, "kmsdev");
+        if (probe_hw_pci(devpath, dev)) {
+            ms_setup_scrn_hooks(scrn);
+
+            xf86DrvMsg(scrn->scrnIndex, X_CONFIG,
+                       "claimed PCI slot %d@%d:%d:%d\n",
+                       dev->bus, dev->domain, dev->dev, dev->func);
+            xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                       "using %s\n", devpath ? devpath : "default device");
+        }
+        else
+            scrn = NULL;
     }
     return scrn != NULL;
 }
@@ -346,29 +365,22 @@ ms_pci_probe(DriverPtr driver,
 #ifdef XSERVER_PLATFORM_BUS
 static Bool
 ms_platform_probe(DriverPtr driver,
-              int entity_num, int flags, struct xf86_platform_device *dev, intptr_t match_data)
+                  int entity_num, int flags, struct xf86_platform_device *dev,
+                  intptr_t match_data)
 {
     ScrnInfoPtr scrn = NULL;
     const char *path = xf86_platform_device_odev_attributes(dev)->path;
     int scr_flags = 0;
 
     if (flags & PLATFORM_PROBE_GPU_SCREEN)
-            scr_flags = XF86_ALLOCATE_GPU_SCREEN;
+        scr_flags = XF86_ALLOCATE_GPU_SCREEN;
 
     if (probe_hw(path, dev)) {
         scrn = xf86AllocateScreen(driver, scr_flags);
         xf86AddEntityToScreen(scrn, entity_num);
 
-        scrn->driverName = "modesetting";
-        scrn->name = "modesetting";
-        scrn->PreInit = PreInit;
-        scrn->ScreenInit = ScreenInit;
-        scrn->SwitchMode = SwitchMode;
-        scrn->AdjustFrame = AdjustFrame;
-        scrn->EnterVT = EnterVT;
-        scrn->LeaveVT = LeaveVT;
-        scrn->FreeScreen = FreeScreen;
-        scrn->ValidMode = ValidMode;
+        ms_setup_scrn_hooks(scrn);
+
         xf86DrvMsg(scrn->scrnIndex, X_INFO,
                    "using drv %s\n", path ? path : "default device");
     }
@@ -388,44 +400,34 @@ Probe(DriverPtr drv, int flags)
 
     /* For now, just bail out for PROBE_DETECT. */
     if (flags & PROBE_DETECT)
-	return FALSE;
+        return FALSE;
 
     /*
      * Find the config file Device sections that match this
      * driver, and return if there are none.
      */
     if ((numDevSections = xf86MatchDevice("modesetting", &devSections)) <= 0) {
-	return FALSE;
+        return FALSE;
     }
 
     for (i = 0; i < numDevSections; i++) {
 
-	dev = xf86FindOptionValue(devSections[i]->options,"kmsdev");
-	if (probe_hw(dev, NULL)) {
-	    int entity;
-	    entity = xf86ClaimFbSlot(drv, 0, devSections[i], TRUE);
-	    scrn = xf86ConfigFbEntity(scrn, 0, entity,
-				  NULL, NULL, NULL, NULL);
-	}
-
-	if (scrn) {
-	    foundScreen = TRUE;
-	    scrn->driverVersion = 1;
-	    scrn->driverName = "modesetting";
-	    scrn->name = "modesetting";
-	    scrn->Probe = Probe;
-	    scrn->PreInit = PreInit;
-	    scrn->ScreenInit = ScreenInit;
-	    scrn->SwitchMode = SwitchMode;
-	    scrn->AdjustFrame = AdjustFrame;
-	    scrn->EnterVT = EnterVT;
-	    scrn->LeaveVT = LeaveVT;
-	    scrn->FreeScreen = FreeScreen;
-	    scrn->ValidMode = ValidMode;
-
-	    xf86DrvMsg(scrn->scrnIndex, X_INFO,
-			   "using %s\n", dev ? dev : "default device");
-	}
+        dev = xf86FindOptionValue(devSections[i]->options, "kmsdev");
+        if (probe_hw(dev, NULL)) {
+            int entity;
+
+            entity = xf86ClaimFbSlot(drv, 0, devSections[i], TRUE);
+            scrn = xf86ConfigFbEntity(scrn, 0, entity, NULL, NULL, NULL, NULL);
+        }
+
+        if (scrn) {
+            foundScreen = TRUE;
+            ms_setup_scrn_hooks(scrn);
+            scrn->Probe = Probe;
+
+            xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                       "using %s\n", dev ? dev : "default device");
+        }
     }
 
     free(devSections);
@@ -437,51 +439,51 @@ static Bool
 GetRec(ScrnInfoPtr pScrn)
 {
     if (pScrn->driverPrivate)
-	return TRUE;
+        return TRUE;
 
     pScrn->driverPrivate = xnfcalloc(sizeof(modesettingRec), 1);
 
     return TRUE;
 }
 
-static int dispatch_dirty_region(ScrnInfoPtr scrn,
-				 PixmapPtr pixmap,
-				 DamagePtr damage,
-				 int fb_id)
+static int
+dispatch_dirty_region(ScrnInfoPtr scrn,
+                      PixmapPtr pixmap, DamagePtr damage, int fb_id)
 {
     modesettingPtr ms = modesettingPTR(scrn);
     RegionPtr dirty = DamageRegion(damage);
     unsigned num_cliprects = REGION_NUM_RECTS(dirty);
 
     if (num_cliprects) {
-	drmModeClip *clip = malloc(num_cliprects * sizeof(drmModeClip));
-	BoxPtr rect = REGION_RECTS(dirty);
-	int i, ret;
-	    
-	if (!clip)
-	    return -ENOMEM;
-
-	/* XXX no need for copy? */
-	for (i = 0; i < num_cliprects; i++, rect++) {
-	    clip[i].x1 = rect->x1;
-	    clip[i].y1 = rect->y1;
-	    clip[i].x2 = rect->x2;
-	    clip[i].y2 = rect->y2;
-	}
-
-	/* TODO query connector property to see if this is needed */
-	ret = drmModeDirtyFB(ms->fd, fb_id, clip, num_cliprects);
-	free(clip);
-	DamageEmpty(damage);
-	if (ret) {
-	    if (ret == -EINVAL)
-		return ret;
-	}
+        drmModeClip *clip = malloc(num_cliprects * sizeof(drmModeClip));
+        BoxPtr rect = REGION_RECTS(dirty);
+        int i, ret;
+
+        if (!clip)
+            return -ENOMEM;
+
+        /* XXX no need for copy? */
+        for (i = 0; i < num_cliprects; i++, rect++) {
+            clip[i].x1 = rect->x1;
+            clip[i].y1 = rect->y1;
+            clip[i].x2 = rect->x2;
+            clip[i].y2 = rect->y2;
+        }
+
+        /* TODO query connector property to see if this is needed */
+        ret = drmModeDirtyFB(ms->fd, fb_id, clip, num_cliprects);
+        free(clip);
+        DamageEmpty(damage);
+        if (ret) {
+            if (ret == -EINVAL)
+                return ret;
+        }
     }
     return 0;
 }
 
-static void dispatch_dirty(ScreenPtr pScreen)
+static void
+dispatch_dirty(ScreenPtr pScreen)
 {
     ScrnInfoPtr scrn = xf86ScreenToScrn(pScreen);
     modesettingPtr ms = modesettingPTR(scrn);
@@ -491,16 +493,18 @@ static void dispatch_dirty(ScreenPtr pScreen)
 
     ret = dispatch_dirty_region(scrn, pixmap, ms->damage, fb_id);
     if (ret == -EINVAL || ret == -ENOSYS) {
-	ms->dirty_enabled = FALSE;
-	DamageUnregister(ms->damage);
-	DamageDestroy(ms->damage);
-	ms->damage = NULL;
-	xf86DrvMsg(scrn->scrnIndex, X_INFO, "Disabling kernel dirty updates, not required.\n");
-	return;
+        ms->dirty_enabled = FALSE;
+        DamageUnregister(ms->damage);
+        DamageDestroy(ms->damage);
+        ms->damage = NULL;
+        xf86DrvMsg(scrn->scrnIndex, X_INFO,
+                   "Disabling kernel dirty updates, not required.\n");
+        return;
     }
 }
 
-static void dispatch_dirty_crtc(ScrnInfoPtr scrn, xf86CrtcPtr crtc)
+static void
+dispatch_dirty_crtc(ScrnInfoPtr scrn, xf86CrtcPtr crtc)
 {
     modesettingPtr ms = modesettingPTR(scrn);
     PixmapPtr pixmap = crtc->randr_crtc->scanout_pixmap;
@@ -516,25 +520,27 @@ static void dispatch_dirty_crtc(ScrnInfoPtr scrn, xf86CrtcPtr crtc)
     }
 }
 
-static void dispatch_slave_dirty(ScreenPtr pScreen)
+static void
+dispatch_slave_dirty(ScreenPtr pScreen)
 {
     ScrnInfoPtr scrn = xf86ScreenToScrn(pScreen);
     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];
+        xf86CrtcPtr crtc = xf86_config->crtc[c];
 
-	if (!crtc->randr_crtc)
-	    continue;
-	if (!crtc->randr_crtc->scanout_pixmap)
-	    continue;
+        if (!crtc->randr_crtc)
+            continue;
+        if (!crtc->randr_crtc->scanout_pixmap)
+            continue;
 
-	dispatch_dirty_crtc(scrn, crtc);
+        dispatch_dirty_crtc(scrn, crtc);
     }
 }
 
-static void msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
+static void
+msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
 {
     modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
 
@@ -568,7 +574,7 @@ FreeRec(ScrnInfoPtr pScrn)
         else
 #ifdef XF86_PDEV_SERVER_FD
         if (!(ms->pEnt->location.type == BUS_PLATFORM &&
-              (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD)))
+                  (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD)))
 #endif
             ret = close(ms->fd);
         (void) ret;
@@ -578,6 +584,43 @@ FreeRec(ScrnInfoPtr pScrn)
 
 }
 
+static void
+try_enable_glamor(ScrnInfoPtr pScrn)
+{
+    modesettingPtr ms = modesettingPTR(pScrn);
+    const char *accel_method_str = xf86GetOptValString(ms->Options,
+                                                       OPTION_ACCEL_METHOD);
+    Bool do_glamor = (!accel_method_str ||
+                      strcmp(accel_method_str, "glamor") == 0);
+
+    ms->glamor = FALSE;
+
+#ifdef GLAMOR
+    if (!do_glamor) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "glamor disabled\n");
+        return;
+    }
+
+    if (xf86LoadSubModule(pScrn, GLAMOR_EGL_MODULE_NAME)) {
+        if (glamor_egl_init(pScrn, ms->fd)) {
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO, "glamor initialized\n");
+            ms->glamor = TRUE;
+        } else {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "glamor initialization failed\n");
+        }
+    } else {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                   "Failed to load glamor module.\n");
+    }
+#else
+    if (do_glamor) {
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                   "No glamor support in the X Server\n");
+    }
+#endif
+}
+
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
@@ -595,45 +638,46 @@ PreInit(ScrnInfoPtr pScrn, int flags)
     EntPtr msEnt = NULL;
     char *BusID = NULL;
     const char *devicename;
-    Bool prefer_shadow = TRUE;
     uint64_t value = 0;
     int ret;
     int bppflags;
     int defaultdepth, defaultbpp;
 
     if (pScrn->numEntities != 1)
-	return FALSE;
+        return FALSE;
 
     pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 
     if (flags & PROBE_DETECT) {
-	return FALSE;
+        return FALSE;
     }
 
     /* Allocate driverPrivate */
     if (!GetRec(pScrn))
-	return FALSE;
+        return FALSE;
 
     ms = modesettingPTR(pScrn);
     ms->SaveGeneration = -1;
     ms->pEnt = pEnt;
 
-    pScrn->displayWidth = 640;	       /* default it */
+    pScrn->displayWidth = 640;  /* default it */
 
     /* Allocate an entity private if necessary */
     if (xf86IsEntityShared(pScrn->entityList[0])) {
-	msEnt = xf86GetEntityPrivate(pScrn->entityList[0],
-				     modesettingEntityIndex)->ptr;
-	ms->entityPrivate = msEnt;
-    } else
-	ms->entityPrivate = NULL;
+        msEnt = xf86GetEntityPrivate(pScrn->entityList[0],
+                                     modesettingEntityIndex)->ptr;
+        ms->entityPrivate = msEnt;
+    }
+    else
+        ms->entityPrivate = NULL;
 
     if (xf86IsEntityShared(pScrn->entityList[0])) {
-	if (xf86IsPrimInitDone(pScrn->entityList[0])) {
-	    /* do something */
-	} else {
-	    xf86SetPrimInitDone(pScrn->entityList[0]);
-	}
+        if (xf86IsPrimInitDone(pScrn->entityList[0])) {
+            /* do something */
+        }
+        else {
+            xf86SetPrimInitDone(pScrn->entityList[0]);
+        }
     }
 
     pScrn->monitor = pScrn->confScreen->monitor;
@@ -644,15 +688,19 @@ PreInit(ScrnInfoPtr pScrn, int flags)
     if (pEnt->location.type == BUS_PLATFORM) {
 #ifdef XF86_PDEV_SERVER_FD
         if (pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD)
-            ms->fd = xf86_platform_device_odev_attributes(pEnt->location.id.plat)->fd;
+            ms->fd =
+                xf86_platform_device_odev_attributes(pEnt->location.id.plat)->
+                fd;
         else
 #endif
         {
-            char *path = xf86_platform_device_odev_attributes(pEnt->location.id.plat)->path;
+            char *path =
+                xf86_platform_device_odev_attributes(pEnt->location.id.plat)->
+                path;
             ms->fd = open_hw(path);
         }
     }
-    else 
+    else
 #endif
     if (pEnt->location.type == BUS_PCI) {
         ms->PciInfo = xf86GetPciInfoForEntity(ms->pEnt->index);
@@ -670,12 +718,13 @@ PreInit(ScrnInfoPtr pScrn, int flags)
                 );
         }
         ms->fd = drmOpen(NULL, BusID);
-    } else {
+    }
+    else {
         devicename = xf86FindOptionValue(ms->pEnt->device->options, "kmsdev");
         ms->fd = open_hw(devicename);
     }
     if (ms->fd < 0)
-	return FALSE;
+        return FALSE;
 
     ms->drmmode.fd = ms->fd;
 
@@ -689,81 +738,93 @@ PreInit(ScrnInfoPtr pScrn, int flags)
 #endif
     drmmode_get_default_bpp(pScrn, &ms->drmmode, &defaultdepth, &defaultbpp);
     if (defaultdepth == 24 && defaultbpp == 24)
-	    bppflags = SupportConvert32to24 | Support24bppFb;
+        bppflags = SupportConvert32to24 | Support24bppFb;
     else
-	    bppflags = PreferConvert24to32 | SupportConvert24to32 | Support32bppFb;
-    
+        bppflags = PreferConvert24to32 | SupportConvert24to32 | Support32bppFb;
+
     if (!xf86SetDepthBpp
-	(pScrn, defaultdepth, defaultdepth, defaultbpp, bppflags))
-	return FALSE;
+        (pScrn, defaultdepth, defaultdepth, defaultbpp, bppflags))
+        return FALSE;
 
     switch (pScrn->depth) {
     case 15:
     case 16:
     case 24:
-	break;
+        break;
     default:
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-		   "Given depth (%d) is not supported by the driver\n",
-		   pScrn->depth);
-	return FALSE;
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                   "Given depth (%d) is not supported by the driver\n",
+                   pScrn->depth);
+        return FALSE;
     }
     xf86PrintDepthBpp(pScrn);
 
     /* Process the options */
     xf86CollectOptions(pScrn, NULL);
     if (!(ms->Options = malloc(sizeof(Options))))
-	return FALSE;
+        return FALSE;
     memcpy(ms->Options, Options, sizeof(Options));
     xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, ms->Options);
 
     if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
-	return FALSE;
+        return FALSE;
     if (!xf86SetDefaultVisual(pScrn, -1))
-	return FALSE;
+        return FALSE;
 
     if (xf86ReturnOptValBool(ms->Options, OPTION_SW_CURSOR, FALSE)) {
-	ms->drmmode.sw_cursor = TRUE;
-    }
-
-    ret = drmGetCap(ms->fd, DRM_CAP_DUMB_PREFER_SHADOW, &value);
-    if (!ret) {
-	prefer_shadow = !!value;
+        ms->drmmode.sw_cursor = TRUE;
     }
 
     ms->cursor_width = 64;
     ms->cursor_height = 64;
     ret = drmGetCap(ms->fd, DRM_CAP_CURSOR_WIDTH, &value);
     if (!ret) {
-	ms->cursor_width = value;
+        ms->cursor_width = value;
     }
     ret = drmGetCap(ms->fd, DRM_CAP_CURSOR_HEIGHT, &value);
     if (!ret) {
-	ms->cursor_height = value;
+        ms->cursor_height = value;
     }
 
-    ms->drmmode.shadow_enable = xf86ReturnOptValBool(ms->Options, OPTION_SHADOW_FB, prefer_shadow);
+    try_enable_glamor(pScrn);
+
+    if (!ms->glamor) {
+        Bool prefer_shadow = TRUE;
+
+        ret = drmGetCap(ms->fd, DRM_CAP_DUMB_PREFER_SHADOW, &value);
+        if (!ret) {
+            prefer_shadow = !!value;
+        }
+
+        ms->drmmode.shadow_enable = xf86ReturnOptValBool(ms->Options,
+                                                         OPTION_SHADOW_FB,
+                                                         prefer_shadow);
+
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                   "ShadowFB: preferred %s, enabled %s\n",
+                   prefer_shadow ? "YES" : "NO",
+                   ms->drmmode.shadow_enable ? "YES" : "NO");
+    }
 
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ShadowFB: preferred %s, enabled %s\n", prefer_shadow ? "YES" : "NO", ms->drmmode.shadow_enable ? "YES" : "NO");
     if (drmmode_pre_init(pScrn, &ms->drmmode, pScrn->bitsPerPixel / 8) == FALSE) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "KMS setup failed\n");
-	goto fail;
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "KMS setup failed\n");
+        goto fail;
     }
 
     /*
      * If the driver can do gamma correction, it should call xf86SetGamma() here.
      */
     {
-	Gamma zeros = { 0.0, 0.0, 0.0 };
+        Gamma zeros = { 0.0, 0.0, 0.0 };
 
-	if (!xf86SetGamma(pScrn, zeros)) {
-	    return FALSE;
-	}
+        if (!xf86SetGamma(pScrn, zeros)) {
+            return FALSE;
+        }
     }
 
     if (pScrn->modes == NULL) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
-	return FALSE;
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
+        return FALSE;
     }
 
     pScrn->currentMode = pScrn->modes;
@@ -773,23 +834,23 @@ PreInit(ScrnInfoPtr pScrn, int flags)
 
     /* Load the required sub modules */
     if (!xf86LoadSubModule(pScrn, "fb")) {
-	return FALSE;
+        return FALSE;
     }
 
     if (ms->drmmode.shadow_enable) {
-	if (!xf86LoadSubModule(pScrn, "shadow")) {
-	    return FALSE;
-	}
+        if (!xf86LoadSubModule(pScrn, "shadow")) {
+            return FALSE;
+        }
     }
 
     return TRUE;
-    fail:
+ fail:
     return FALSE;
 }
 
 static void *
 msShadowWindow(ScreenPtr screen, CARD32 row, CARD32 offset, int mode,
-	       CARD32 *size, void *closure)
+               CARD32 *size, void *closure)
 {
     ScrnInfoPtr pScrn = xf86ScreenToScrn(screen);
     modesettingPtr ms = modesettingPTR(pScrn);
@@ -798,7 +859,7 @@ msShadowWindow(ScreenPtr screen, CARD32 row, CARD32 offset, int mode,
     stride = (pScrn->displayWidth * pScrn->bitsPerPixel) / 8;
     *size = stride;
 
-    return ((uint8_t *)ms->drmmode.front_bo->ptr + row * stride + offset);
+    return ((uint8_t *) ms->drmmode.front_bo->ptr + row * stride + offset);
 }
 
 static void
@@ -815,12 +876,27 @@ CreateScreenResources(ScreenPtr pScreen)
     PixmapPtr rootPixmap;
     Bool ret;
     void *pixels;
+
     pScreen->CreateScreenResources = ms->createScreenResources;
     ret = pScreen->CreateScreenResources(pScreen);
     pScreen->CreateScreenResources = CreateScreenResources;
 
     if (!drmmode_set_desired_modes(pScrn, &ms->drmmode))
-      return FALSE;
+        return FALSE;
+
+#ifdef GLAMOR
+    if (ms->glamor) {
+        if (!glamor_egl_create_textured_screen_ext(pScreen,
+                                                   ms->drmmode.front_bo->handle,
+                                                   pScrn->displayWidth *
+                                                   pScrn->bitsPerPixel / 8,
+                                                   NULL)) {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "glamor_egl_create_textured_screen_ext() failed\n");
+            return FALSE;
+        }
+    }
+#endif
 
     drmmode_uevent_init(pScrn, &ms->drmmode);
 
@@ -828,33 +904,34 @@ CreateScreenResources(ScreenPtr pScreen)
         drmmode_map_cursor_bos(pScrn, &ms->drmmode);
     pixels = drmmode_map_front_bo(&ms->drmmode);
     if (!pixels)
-	return FALSE;
+        return FALSE;
 
     rootPixmap = pScreen->GetScreenPixmap(pScreen);
 
     if (ms->drmmode.shadow_enable)
-	pixels = ms->drmmode.shadow_fb;
-    
+        pixels = ms->drmmode.shadow_fb;
+
     if (!pScreen->ModifyPixmapHeader(rootPixmap, -1, -1, -1, -1, -1, pixels))
-	FatalError("Couldn't adjust screen pixmap\n");
+        FatalError("Couldn't adjust screen pixmap\n");
 
     if (ms->drmmode.shadow_enable) {
-	if (!shadowAdd(pScreen, rootPixmap, msUpdatePacked,
-		       msShadowWindow, 0, 0))
-	    return FALSE;
+        if (!shadowAdd(pScreen, rootPixmap, msUpdatePacked,
+                       msShadowWindow, 0, 0))
+            return FALSE;
     }
 
     ms->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE,
                               pScreen, rootPixmap);
 
     if (ms->damage) {
-	DamageRegister(&rootPixmap->drawable, ms->damage);
-	ms->dirty_enabled = TRUE;
-	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
-    } else {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-		   "Failed to create screen damage record\n");
-	return FALSE;
+        DamageRegister(&rootPixmap->drawable, ms->damage);
+        ms->dirty_enabled = TRUE;
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
+    }
+    else {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                   "Failed to create screen damage record\n");
+        return FALSE;
     }
     return ret;
 }
@@ -863,7 +940,7 @@ static Bool
 msShadowInit(ScreenPtr pScreen)
 {
     if (!shadowSetup(pScreen)) {
-	return FALSE;
+        return FALSE;
     }
     return TRUE;
 }
@@ -876,11 +953,11 @@ msSetSharedPixmapBacking(PixmapPtr ppix, void *fd_handle)
     modesettingPtr ms = modesettingPTR(scrn);
     Bool ret;
     int size = ppix->devKind * ppix->drawable.height;
-    int ihandle = (int)(long)fd_handle;
+    int ihandle = (int) (long) fd_handle;
 
     ret = drmmode_SetSlaveBO(ppix, &ms->drmmode, ihandle, ppix->devKind, size);
     if (ret == FALSE)
-	    return ret;
+        return ret;
 
     return TRUE;
 }
@@ -893,7 +970,7 @@ SetMaster(ScrnInfoPtr pScrn)
 
 #ifdef XF86_PDEV_SERVER_FD
     if (ms->pEnt->location.type == BUS_PLATFORM &&
-            (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD))
+        (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD))
         return TRUE;
 #endif
 
@@ -920,62 +997,77 @@ ScreenInit(ScreenPtr pScreen, int argc, char **argv)
     /* HW dependent - FIXME */
     pScrn->displayWidth = pScrn->virtualX;
     if (!drmmode_create_initial_bos(pScrn, &ms->drmmode))
-	return FALSE;
+        return FALSE;
 
     if (ms->drmmode.shadow_enable) {
-	ms->drmmode.shadow_fb = calloc(1, pScrn->displayWidth * pScrn->virtualY *
-			       ((pScrn->bitsPerPixel + 7) >> 3));
-	if (!ms->drmmode.shadow_fb)
-	    ms->drmmode.shadow_enable = FALSE;
-    }	
-    
+        ms->drmmode.shadow_fb =
+            calloc(1,
+                   pScrn->displayWidth * pScrn->virtualY *
+                   ((pScrn->bitsPerPixel + 7) >> 3));
+        if (!ms->drmmode.shadow_fb)
+            ms->drmmode.shadow_enable = FALSE;
+    }
+
     miClearVisualTypes();
 
     if (!miSetVisualTypes(pScrn->depth,
-			  miGetDefaultVisualMask(pScrn->depth),
-			  pScrn->rgbBits, pScrn->defaultVisual))
-	return FALSE;
+                          miGetDefaultVisualMask(pScrn->depth),
+                          pScrn->rgbBits, pScrn->defaultVisual))
+        return FALSE;
 
     if (!miSetPixmapDepths())
-	return FALSE;
+        return FALSE;
 
-    if (!dixRegisterScreenSpecificPrivateKey(pScreen, &ms->drmmode.pixmapPrivateKeyRec,
-        PRIVATE_PIXMAP, sizeof(msPixmapPrivRec))) { 
-	return FALSE;
+    if (!dixRegisterScreenSpecificPrivateKey
+        (pScreen, &ms->drmmode.pixmapPrivateKeyRec, PRIVATE_PIXMAP,
+         sizeof(msPixmapPrivRec))) {
+        return FALSE;
     }
 
     pScrn->memPhysBase = 0;
     pScrn->fbOffset = 0;
 
     if (!fbScreenInit(pScreen, NULL,
-		      pScrn->virtualX, pScrn->virtualY,
-		      pScrn->xDpi, pScrn->yDpi,
-		      pScrn->displayWidth, pScrn->bitsPerPixel))
-	return FALSE;
+                      pScrn->virtualX, pScrn->virtualY,
+                      pScrn->xDpi, pScrn->yDpi,
+                      pScrn->displayWidth, pScrn->bitsPerPixel))
+        return FALSE;
 
     if (pScrn->bitsPerPixel > 8) {
-	/* Fixup RGB ordering */
-	visual = pScreen->visuals + pScreen->numVisuals;
-	while (--visual >= pScreen->visuals) {
-	    if ((visual->class | DynamicClass) == DirectColor) {
-		visual->offsetRed = pScrn->offset.red;
-		visual->offsetGreen = pScrn->offset.green;
-		visual->offsetBlue = pScrn->offset.blue;
-		visual->redMask = pScrn->mask.red;
-		visual->greenMask = pScrn->mask.green;
-		visual->blueMask = pScrn->mask.blue;
-	    }
-	}
+        /* Fixup RGB ordering */
+        visual = pScreen->visuals + pScreen->numVisuals;
+        while (--visual >= pScreen->visuals) {
+            if ((visual->class | DynamicClass) == DirectColor) {
+                visual->offsetRed = pScrn->offset.red;
+                visual->offsetGreen = pScrn->offset.green;
+                visual->offsetBlue = pScrn->offset.blue;
+                visual->redMask = pScrn->mask.red;
+                visual->greenMask = pScrn->mask.green;
+                visual->blueMask = pScrn->mask.blue;
+            }
+        }
     }
 
     fbPictureInit(pScreen, NULL, 0);
 
+#ifdef GLAMOR
+    if (ms->glamor) {
+        if (!glamor_init(pScreen,
+                         GLAMOR_USE_EGL_SCREEN |
+                         GLAMOR_USE_SCREEN |
+                         GLAMOR_USE_PICTURE_SCREEN)) {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "Failed to initialize glamor at ScreenInit() time.\n");
+            return FALSE;
+        }
+    }
+#endif
+
     if (ms->drmmode.shadow_enable && !msShadowInit(pScreen)) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-		   "shadow fb init failed\n");
-	return FALSE;
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "shadow fb init failed\n");
+        return FALSE;
     }
-  
+
     ms->createScreenResources = pScreen->CreateScreenResources;
     pScreen->CreateScreenResources = CreateScreenResources;
 
@@ -987,9 +1079,9 @@ ScreenInit(ScreenPtr pScreen, int argc, char **argv)
 
     /* Need to extend HWcursor support to handle mask interleave */
     if (!ms->drmmode.sw_cursor)
-	xf86_cursors_init(pScreen, ms->cursor_width, ms->cursor_height,
-			  HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 |
-			  HARDWARE_CURSOR_ARGB);
+        xf86_cursors_init(pScreen, ms->cursor_width, ms->cursor_height,
+                          HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 |
+                          HARDWARE_CURSOR_ARGB);
 
     /* Must force it before EnterVT, so we are in control of VT and
      * later memory should be bound when allocating, e.g rotate_mem */
@@ -1005,15 +1097,15 @@ ScreenInit(ScreenPtr pScreen, int argc, char **argv)
     pScreen->SetSharedPixmapBacking = msSetSharedPixmapBacking;
 
     if (!xf86CrtcScreenInit(pScreen))
-	return FALSE;
+        return FALSE;
 
     if (!miCreateDefColormap(pScreen))
-	return FALSE;
+        return FALSE;
 
     xf86DPMSInit(pScreen, xf86DPMSSet, 0);
 
     if (serverGeneration == 1)
-	xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+        xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
 
     return EnterVT(pScrn);
 }
@@ -1036,13 +1128,14 @@ static void
 LeaveVT(ScrnInfoPtr pScrn)
 {
     modesettingPtr ms = modesettingPTR(pScrn);
+
     xf86_hide_cursors(pScrn);
 
     pScrn->vtSema = FALSE;
 
 #ifdef XF86_PDEV_SERVER_FD
     if (ms->pEnt->location.type == BUS_PLATFORM &&
-            (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD))
+        (ms->pEnt->location.id.plat->flags & XF86_PDEV_SERVER_FD))
         return;
 #endif
 
@@ -1062,7 +1155,7 @@ EnterVT(ScrnInfoPtr pScrn)
     SetMaster(pScrn);
 
     if (!drmmode_set_desired_modes(pScrn, &ms->drmmode))
-	return FALSE;
+        return FALSE;
 
     return TRUE;
 }
@@ -1080,15 +1173,15 @@ CloseScreen(ScreenPtr pScreen)
     modesettingPtr ms = modesettingPTR(pScrn);
 
     if (ms->damage) {
-	DamageUnregister(ms->damage);
-	DamageDestroy(ms->damage);
-	ms->damage = NULL;
+        DamageUnregister(ms->damage);
+        DamageDestroy(ms->damage);
+        ms->damage = NULL;
     }
 
     if (ms->drmmode.shadow_enable) {
-	shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
-	free(ms->drmmode.shadow_fb);
-	ms->drmmode.shadow_fb = NULL;
+        shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
+        free(ms->drmmode.shadow_fb);
+        ms->drmmode.shadow_fb = NULL;
     }
     drmmode_uevent_fini(pScrn, &ms->drmmode);
 
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/driver.h b/xorg-server/hw/xfree86/drivers/modesetting/driver.h
index 450b29c2b..35f24193a 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/driver.h
+++ b/xorg-server/hw/xfree86/drivers/modesetting/driver.h
@@ -35,16 +35,14 @@
 #include "drmmode_display.h"
 #define DRV_ERROR(msg)	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, msg);
 
-typedef struct
-{
+typedef struct {
     int lastInstance;
     int refCount;
     ScrnInfoPtr pScrn_1;
     ScrnInfoPtr pScrn_2;
 } EntRec, *EntPtr;
 
-typedef struct _modesettingRec
-{
+typedef struct _modesettingRec {
     int fd;
 
     EntPtr entityPrivate;
@@ -76,6 +74,7 @@ typedef struct _modesettingRec
     Bool dirty_enabled;
 
     uint32_t cursor_width, cursor_height;
+    Bool glamor;
 } modesettingRec, *modesettingPtr;
 
 #define modesettingPTR(p) ((modesettingPtr)((p)->driverPrivate))
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.c b/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.c
index 9723ccd0e..d959837ae 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.c
+++ b/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.c
@@ -49,181 +49,183 @@
 
 #include "driver.h"
 
-static struct dumb_bo *dumb_bo_create(int fd,
-			  const unsigned width, const unsigned height,
-			  const unsigned bpp)
+static struct dumb_bo *
+dumb_bo_create(int fd,
+               const unsigned width, const unsigned height, const unsigned bpp)
 {
-	struct drm_mode_create_dumb arg;
-	struct dumb_bo *bo;
-	int ret;
-
-	bo = calloc(1, sizeof(*bo));
-	if (!bo)
-		return NULL;
-
-	memset(&arg, 0, sizeof(arg));
-	arg.width = width;
-	arg.height = height;
-	arg.bpp = bpp;
-	
-	ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &arg);
-	if (ret)
-		goto err_free;
-
-	bo->handle = arg.handle;
-	bo->size = arg.size;
-	bo->pitch = arg.pitch;
-
-	return bo;
+    struct drm_mode_create_dumb arg;
+    struct dumb_bo *bo;
+    int ret;
+
+    bo = calloc(1, sizeof(*bo));
+    if (!bo)
+        return NULL;
+
+    memset(&arg, 0, sizeof(arg));
+    arg.width = width;
+    arg.height = height;
+    arg.bpp = bpp;
+
+    ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &arg);
+    if (ret)
+        goto err_free;
+
+    bo->handle = arg.handle;
+    bo->size = arg.size;
+    bo->pitch = arg.pitch;
+
+    return bo;
  err_free:
-	free(bo);
-	return NULL;
+    free(bo);
+    return NULL;
 }
 
-static int dumb_bo_map(int fd, struct dumb_bo *bo)
+static int
+dumb_bo_map(int fd, struct dumb_bo *bo)
 {
-	struct drm_mode_map_dumb arg;
-	int ret;
-	void *map;
+    struct drm_mode_map_dumb arg;
+    int ret;
+    void *map;
 
-	if (bo->ptr) {
-		bo->map_count++;
-		return 0;
-	}
+    if (bo->ptr) {
+        bo->map_count++;
+        return 0;
+    }
 
-	memset(&arg, 0, sizeof(arg));
-	arg.handle = bo->handle;
+    memset(&arg, 0, sizeof(arg));
+    arg.handle = bo->handle;
 
-	ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &arg);
-	if (ret)
-		return ret;
+    ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &arg);
+    if (ret)
+        return ret;
 
-	map = mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
-		   fd, arg.offset);
-	if (map == MAP_FAILED)
-		return -errno;
+    map = mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, arg.offset);
+    if (map == MAP_FAILED)
+        return -errno;
 
-	bo->ptr = map;
-	return 0;
+    bo->ptr = map;
+    return 0;
 }
 
 #if 0
-static int dumb_bo_unmap(int fd, struct dumb_bo *bo)
+static int
+dumb_bo_unmap(int fd, struct dumb_bo *bo)
 {
-	bo->map_count--;
-	return 0;
+    bo->map_count--;
+    return 0;
 }
 #endif
 
-static int dumb_bo_destroy(int fd, struct dumb_bo *bo)
+static int
+dumb_bo_destroy(int fd, struct dumb_bo *bo)
 {
-	struct drm_mode_destroy_dumb arg;
-	int ret;
-	
-	if (bo->ptr) {
-		munmap(bo->ptr, bo->size);
-		bo->ptr = NULL;
-	}
-
-	memset(&arg, 0, sizeof(arg));
-	arg.handle = bo->handle;
-	ret = drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
-	if (ret)
-		return -errno;
-
-	free(bo);
-	return 0;
+    struct drm_mode_destroy_dumb arg;
+    int ret;
+
+    if (bo->ptr) {
+        munmap(bo->ptr, bo->size);
+        bo->ptr = NULL;
+    }
+
+    memset(&arg, 0, sizeof(arg));
+    arg.handle = bo->handle;
+    ret = drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
+    if (ret)
+        return -errno;
+
+    free(bo);
+    return 0;
 }
 
-static struct dumb_bo *dumb_get_bo_from_handle(int fd, int handle, int pitch, int size)
+static struct dumb_bo *
+dumb_get_bo_from_handle(int fd, int handle, int pitch, int size)
 {
-  	struct dumb_bo *bo;
-	int ret;
-
-	bo = calloc(1, sizeof(*bo));
-	if (!bo)
-		return NULL;
-
-	ret = drmPrimeFDToHandle(fd, handle, &bo->handle);
-	if (ret) {
-		free(bo);
-		return NULL;
-	}
-	bo->pitch = pitch;
-	bo->size = size;
-	return bo;
+    struct dumb_bo *bo;
+    int ret;
+
+    bo = calloc(1, sizeof(*bo));
+    if (!bo)
+        return NULL;
+
+    ret = drmPrimeFDToHandle(fd, handle, &bo->handle);
+    if (ret) {
+        free(bo);
+        return NULL;
+    }
+    bo->pitch = pitch;
+    bo->size = size;
+    return bo;
 }
 
-Bool drmmode_SetSlaveBO(PixmapPtr ppix,
-			drmmode_ptr drmmode, 
-			int fd_handle, int pitch, int size)
+Bool
+drmmode_SetSlaveBO(PixmapPtr ppix,
+                   drmmode_ptr drmmode, int fd_handle, int pitch, int size)
 {
-    	msPixmapPrivPtr ppriv = msGetPixmapPriv(drmmode, ppix);
+    msPixmapPrivPtr ppriv = msGetPixmapPriv(drmmode, ppix);
 
-	ppriv->backing_bo = dumb_get_bo_from_handle(drmmode->fd, fd_handle, pitch, size);
-	if (!ppriv->backing_bo)
-		return FALSE;
+    ppriv->backing_bo =
+        dumb_get_bo_from_handle(drmmode->fd, fd_handle, pitch, size);
+    if (!ppriv->backing_bo)
+        return FALSE;
 
-	close(fd_handle);
-	return TRUE;
+    close(fd_handle);
+    return TRUE;
 }
 
 static void
-drmmode_ConvertFromKMode(ScrnInfoPtr	scrn,
-		     drmModeModeInfo *kmode,
-		     DisplayModePtr	mode)
+drmmode_ConvertFromKMode(ScrnInfoPtr scrn,
+                         drmModeModeInfo * kmode, DisplayModePtr mode)
 {
-	memset(mode, 0, sizeof(DisplayModeRec));
-	mode->status = MODE_OK;
-
-	mode->Clock = kmode->clock;
-
-	mode->HDisplay = kmode->hdisplay;
-	mode->HSyncStart = kmode->hsync_start;
-	mode->HSyncEnd = kmode->hsync_end;
-	mode->HTotal = kmode->htotal;
-	mode->HSkew = kmode->hskew;
-
-	mode->VDisplay = kmode->vdisplay;
-	mode->VSyncStart = kmode->vsync_start;
-	mode->VSyncEnd = kmode->vsync_end;
-	mode->VTotal = kmode->vtotal;
-	mode->VScan = kmode->vscan;
-
-	mode->Flags = kmode->flags; //& FLAG_BITS;
-	mode->name = strdup(kmode->name);
-
-	if (kmode->type & DRM_MODE_TYPE_DRIVER)
-		mode->type = M_T_DRIVER;
-	if (kmode->type & DRM_MODE_TYPE_PREFERRED)
-		mode->type |= M_T_PREFERRED;
-	xf86SetModeCrtc (mode, scrn->adjustFlags);
+    memset(mode, 0, sizeof(DisplayModeRec));
+    mode->status = MODE_OK;
+
+    mode->Clock = kmode->clock;
+
+    mode->HDisplay = kmode->hdisplay;
+    mode->HSyncStart = kmode->hsync_start;
+    mode->HSyncEnd = kmode->hsync_end;
+    mode->HTotal = kmode->htotal;
+    mode->HSkew = kmode->hskew;
+
+    mode->VDisplay = kmode->vdisplay;
+    mode->VSyncStart = kmode->vsync_start;
+    mode->VSyncEnd = kmode->vsync_end;
+    mode->VTotal = kmode->vtotal;
+    mode->VScan = kmode->vscan;
+
+    mode->Flags = kmode->flags; //& FLAG_BITS;
+    mode->name = strdup(kmode->name);
+
+    if (kmode->type & DRM_MODE_TYPE_DRIVER)
+        mode->type = M_T_DRIVER;
+    if (kmode->type & DRM_MODE_TYPE_PREFERRED)
+        mode->type |= M_T_PREFERRED;
+    xf86SetModeCrtc(mode, scrn->adjustFlags);
 }
 
 static void
-drmmode_ConvertToKMode(ScrnInfoPtr	scrn,
-		     drmModeModeInfo *kmode,
-		     DisplayModePtr	mode)
+drmmode_ConvertToKMode(ScrnInfoPtr scrn,
+                       drmModeModeInfo * kmode, DisplayModePtr mode)
 {
-	memset(kmode, 0, sizeof(*kmode));
-
-	kmode->clock = mode->Clock;
-	kmode->hdisplay = mode->HDisplay;
-	kmode->hsync_start = mode->HSyncStart;
-	kmode->hsync_end = mode->HSyncEnd;
-	kmode->htotal = mode->HTotal;
-	kmode->hskew = mode->HSkew;
-
-	kmode->vdisplay = mode->VDisplay;
-	kmode->vsync_start = mode->VSyncStart;
-	kmode->vsync_end = mode->VSyncEnd;
-	kmode->vtotal = mode->VTotal;
-	kmode->vscan = mode->VScan;
-
-	kmode->flags = mode->Flags; //& FLAG_BITS;
-	if (mode->name)
-		strncpy(kmode->name, mode->name, DRM_DISPLAY_MODE_LEN);
-	kmode->name[DRM_DISPLAY_MODE_LEN-1] = 0;
+    memset(kmode, 0, sizeof(*kmode));
+
+    kmode->clock = mode->Clock;
+    kmode->hdisplay = mode->HDisplay;
+    kmode->hsync_start = mode->HSyncStart;
+    kmode->hsync_end = mode->HSyncEnd;
+    kmode->htotal = mode->HTotal;
+    kmode->hskew = mode->HSkew;
+
+    kmode->vdisplay = mode->VDisplay;
+    kmode->vsync_start = mode->VSyncStart;
+    kmode->vsync_end = mode->VSyncEnd;
+    kmode->vtotal = mode->VTotal;
+    kmode->vscan = mode->VScan;
+
+    kmode->flags = mode->Flags; //& FLAG_BITS;
+    if (mode->name)
+        strncpy(kmode->name, mode->name, DRM_DISPLAY_MODE_LEN);
+    kmode->name[DRM_DISPLAY_MODE_LEN - 1] = 0;
 
 }
 
@@ -231,331 +233,337 @@ static void
 drmmode_crtc_dpms(xf86CrtcPtr crtc, int mode)
 {
 #if 0
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
-//	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-//	drmmode_ptr drmmode = drmmode_crtc->drmmode;
-
-	/* bonghits in the randr 1.2 - uses dpms to disable crtc - bad buzz */
-	if (mode == DPMSModeOff) {
-//		drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
-//			       0, 0, 0, NULL, 0, NULL);
-	}
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+
+//      drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+//      drmmode_ptr drmmode = drmmode_crtc->drmmode;
+
+    /* bonghits in the randr 1.2 - uses dpms to disable crtc - bad buzz */
+    if (mode == DPMSModeOff) {
+//              drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
+//                             0, 0, 0, NULL, 0, NULL);
+    }
 #endif
 }
 
 #if 0
 static PixmapPtr
-create_pixmap_for_fbcon(drmmode_ptr drmmode,
-			ScrnInfoPtr pScrn, int crtc_id)
+create_pixmap_for_fbcon(drmmode_ptr drmmode, ScrnInfoPtr pScrn, int crtc_id)
 {
-	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-	drmmode_crtc_private_ptr drmmode_crtc;
-	ScreenPtr pScreen = pScrn->pScreen;
-	PixmapPtr pixmap;
-	struct radeon_bo *bo;
-	drmModeFBPtr fbcon;
-	struct drm_gem_flink flink;
-
-	drmmode_crtc = xf86_config->crtc[crtc_id]->driver_private;
-
-	fbcon = drmModeGetFB(drmmode->fd, drmmode_crtc->mode_crtc->buffer_id);
-	if (fbcon == NULL)
-		return NULL;
-
-	flink.handle = fbcon->handle;
-	if (ioctl(drmmode->fd, DRM_IOCTL_GEM_FLINK, &flink) < 0) {
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-			   "Couldn't flink fbcon handle\n");
-		return NULL;
-	}
-
-	bo = radeon_bo_open(drmmode->bufmgr, flink.name, 0, 0, 0, 0);
-	if (bo == NULL) {
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-			   "Couldn't allocate bo for fbcon handle\n");
-		return NULL;
-	}
-
-	pixmap = drmmode_create_bo_pixmap(pScreen, fbcon->width, fbcon->height,
-					  fbcon->depth, fbcon->bpp,
-					  fbcon->pitch, bo);
-	if (!pixmap) 
-		return NULL;
-
-	radeon_bo_unref(bo);
-	drmModeFreeFB(fbcon);
-	return pixmap;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    drmmode_crtc_private_ptr drmmode_crtc;
+    ScreenPtr pScreen = pScrn->pScreen;
+    PixmapPtr pixmap;
+    struct radeon_bo *bo;
+    drmModeFBPtr fbcon;
+    struct drm_gem_flink flink;
+
+    drmmode_crtc = xf86_config->crtc[crtc_id]->driver_private;
+
+    fbcon = drmModeGetFB(drmmode->fd, drmmode_crtc->mode_crtc->buffer_id);
+    if (fbcon == NULL)
+        return NULL;
+
+    flink.handle = fbcon->handle;
+    if (ioctl(drmmode->fd, DRM_IOCTL_GEM_FLINK, &flink) < 0) {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Couldn't flink fbcon handle\n");
+        return NULL;
+    }
+
+    bo = radeon_bo_open(drmmode->bufmgr, flink.name, 0, 0, 0, 0);
+    if (bo == NULL) {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                   "Couldn't allocate bo for fbcon handle\n");
+        return NULL;
+    }
+
+    pixmap = drmmode_create_bo_pixmap(pScreen, fbcon->width, fbcon->height,
+                                      fbcon->depth, fbcon->bpp,
+                                      fbcon->pitch, bo);
+    if (!pixmap)
+        return NULL;
+
+    radeon_bo_unref(bo);
+    drmModeFreeFB(fbcon);
+    return pixmap;
 }
 
 #endif
 
 static Bool
 drmmode_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode,
-		     Rotation rotation, int x, int y)
+                       Rotation rotation, int x, int y)
 {
-	ScrnInfoPtr pScrn = crtc->scrn;
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
-	int saved_x, saved_y;
-	Rotation saved_rotation;
-	DisplayModeRec saved_mode;
-	uint32_t *output_ids;
-	int output_count = 0;
-	Bool ret = TRUE;
-	int i;
-	uint32_t fb_id;
-	drmModeModeInfo kmode;
-	int height;
-
-	height = pScrn->virtualY;
-
-	if (drmmode->fb_id == 0) {
-		ret = drmModeAddFB(drmmode->fd,
-				   pScrn->virtualX, height,
-                                   pScrn->depth, pScrn->bitsPerPixel,
-				   drmmode->front_bo->pitch,
-				   drmmode->front_bo->handle,
-                                   &drmmode->fb_id);
-                if (ret < 0) {
-                        ErrorF("failed to add fb %d\n", ret);
-                        return FALSE;
-                }
+    ScrnInfoPtr pScrn = crtc->scrn;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    int saved_x, saved_y;
+    Rotation saved_rotation;
+    DisplayModeRec saved_mode;
+    uint32_t *output_ids;
+    int output_count = 0;
+    Bool ret = TRUE;
+    int i;
+    uint32_t fb_id;
+    drmModeModeInfo kmode;
+    int height;
+
+    height = pScrn->virtualY;
+
+    if (drmmode->fb_id == 0) {
+        ret = drmModeAddFB(drmmode->fd,
+                           pScrn->virtualX, height,
+                           pScrn->depth, pScrn->bitsPerPixel,
+                           drmmode->front_bo->pitch,
+                           drmmode->front_bo->handle, &drmmode->fb_id);
+        if (ret < 0) {
+            ErrorF("failed to add fb %d\n", ret);
+            return FALSE;
+        }
+    }
+
+    saved_mode = crtc->mode;
+    saved_x = crtc->x;
+    saved_y = crtc->y;
+    saved_rotation = crtc->rotation;
+
+    if (mode) {
+        crtc->mode = *mode;
+        crtc->x = x;
+        crtc->y = y;
+        crtc->rotation = rotation;
+        crtc->transformPresent = FALSE;
+    }
+
+    output_ids = calloc(sizeof(uint32_t), xf86_config->num_output);
+    if (!output_ids) {
+        ret = FALSE;
+        goto done;
+    }
+
+    if (mode) {
+        for (i = 0; i < xf86_config->num_output; i++) {
+            xf86OutputPtr output = xf86_config->output[i];
+            drmmode_output_private_ptr drmmode_output;
+
+            if (output->crtc != crtc)
+                continue;
+
+            drmmode_output = output->driver_private;
+            output_ids[output_count] =
+                drmmode_output->mode_output->connector_id;
+            output_count++;
         }
 
-	saved_mode = crtc->mode;
-	saved_x = crtc->x;
-	saved_y = crtc->y;
-	saved_rotation = crtc->rotation;
-
-	if (mode) {
-		crtc->mode = *mode;
-		crtc->x = x;
-		crtc->y = y;
-		crtc->rotation = rotation;
-		crtc->transformPresent = FALSE;
-	}
-
-	output_ids = calloc(sizeof(uint32_t), xf86_config->num_output);
-	if (!output_ids) {
-		ret = FALSE;
-		goto done;
-	}
-
-	if (mode) {
-		for (i = 0; i < xf86_config->num_output; i++) {
-			xf86OutputPtr output = xf86_config->output[i];
-			drmmode_output_private_ptr drmmode_output;
-
-			if (output->crtc != crtc)
-				continue;
-
-			drmmode_output = output->driver_private;
-			output_ids[output_count] = drmmode_output->mode_output->connector_id;
-			output_count++;
-		}
-
-		if (!xf86CrtcRotate(crtc)) {
-			goto done;
-		}
-		crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
-				       crtc->gamma_blue, crtc->gamma_size);
-		
-		drmmode_ConvertToKMode(crtc->scrn, &kmode, mode);
-
-		fb_id = drmmode->fb_id;
-		if (crtc->randr_crtc->scanout_pixmap) {
-    			msPixmapPrivPtr ppriv = msGetPixmapPriv(drmmode, crtc->randr_crtc->scanout_pixmap);
-			fb_id = ppriv->fb_id;
-			x = y = 0;
-		} else if (drmmode_crtc->rotate_fb_id) {
-			fb_id = drmmode_crtc->rotate_fb_id;
-			x = y = 0;
-		}
-		ret = drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
-				     fb_id, x, y, output_ids, output_count, &kmode);
-		if (ret)
-			xf86DrvMsg(crtc->scrn->scrnIndex, X_ERROR,
-				   "failed to set mode: %s", strerror(-ret));
-		else
-			ret = TRUE;
-
-		if (crtc->scrn->pScreen)
-			xf86CrtcSetScreenSubpixelOrder(crtc->scrn->pScreen);
-		/* go through all the outputs and force DPMS them back on? */
-		for (i = 0; i < xf86_config->num_output; i++) {
-			xf86OutputPtr output = xf86_config->output[i];
-
-			if (output->crtc != crtc)
-				continue;
-
-			output->funcs->dpms(output, DPMSModeOn);
-		}
-	}
+        if (!xf86CrtcRotate(crtc)) {
+            goto done;
+        }
+        crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
+                               crtc->gamma_blue, crtc->gamma_size);
+
+        drmmode_ConvertToKMode(crtc->scrn, &kmode, mode);
+
+        fb_id = drmmode->fb_id;
+        if (crtc->randr_crtc->scanout_pixmap) {
+            msPixmapPrivPtr ppriv =
+                msGetPixmapPriv(drmmode, crtc->randr_crtc->scanout_pixmap);
+            fb_id = ppriv->fb_id;
+            x = y = 0;
+        }
+        else if (drmmode_crtc->rotate_fb_id) {
+            fb_id = drmmode_crtc->rotate_fb_id;
+            x = y = 0;
+        }
+        ret = drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
+                             fb_id, x, y, output_ids, output_count, &kmode);
+        if (ret)
+            xf86DrvMsg(crtc->scrn->scrnIndex, X_ERROR,
+                       "failed to set mode: %s", strerror(-ret));
+        else
+            ret = TRUE;
+
+        if (crtc->scrn->pScreen)
+            xf86CrtcSetScreenSubpixelOrder(crtc->scrn->pScreen);
+        /* go through all the outputs and force DPMS them back on? */
+        for (i = 0; i < xf86_config->num_output; i++) {
+            xf86OutputPtr output = xf86_config->output[i];
+
+            if (output->crtc != crtc)
+                continue;
+
+            output->funcs->dpms(output, DPMSModeOn);
+        }
+    }
 
 #if 0
-	if (pScrn->pScreen &&
-		!xf86ReturnOptValBool(info->Options, OPTION_SW_CURSOR, FALSE))
-		xf86_reload_cursors(pScrn->pScreen);
+    if (pScrn->pScreen &&
+        !xf86ReturnOptValBool(info->Options, OPTION_SW_CURSOR, FALSE))
+        xf86_reload_cursors(pScrn->pScreen);
 #endif
-done:
-	if (!ret) {
-		crtc->x = saved_x;
-		crtc->y = saved_y;
-		crtc->rotation = saved_rotation;
-		crtc->mode = saved_mode;
-	}
+ done:
+    if (!ret) {
+        crtc->x = saved_x;
+        crtc->y = saved_y;
+        crtc->rotation = saved_rotation;
+        crtc->mode = saved_mode;
+    }
 #if defined(XF86_CRTC_VERSION) && XF86_CRTC_VERSION >= 3
-	else
-		crtc->active = TRUE;
+    else
+        crtc->active = TRUE;
 #endif
 
-	return ret;
+    return ret;
 }
 
 static void
-drmmode_set_cursor_colors (xf86CrtcPtr crtc, int bg, int fg)
+drmmode_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg)
 {
 
 }
 
 static void
-drmmode_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
+drmmode_set_cursor_position(xf86CrtcPtr crtc, int x, int y)
 {
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
 
-	drmModeMoveCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, x, y);
+    drmModeMoveCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, x, y);
 }
 
 static void
-drmmode_load_cursor_argb (xf86CrtcPtr crtc, CARD32 *image)
+drmmode_load_cursor_argb(xf86CrtcPtr crtc, CARD32 *image)
 {
-	modesettingPtr ms = modesettingPTR(crtc->scrn);
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	int i;
-	uint32_t *ptr;
-	uint32_t handle = drmmode_crtc->cursor_bo->handle;
-	int ret;
-	/* cursor should be mapped already */
-	ptr = (uint32_t *)(drmmode_crtc->cursor_bo->ptr);
-
-	for (i = 0; i < ms->cursor_width * ms->cursor_height; i++)
-		ptr[i] = image[i];// cpu_to_le32(image[i]);
-
-	ret = drmModeSetCursor(drmmode_crtc->drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, handle,
-			       ms->cursor_width, ms->cursor_height);
-	if (ret) {
-		xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
-		xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
-		
-		cursor_info->MaxWidth = cursor_info->MaxHeight = 0;
-		drmmode_crtc->drmmode->sw_cursor = TRUE;
-		/* fallback to swcursor */
-	}
+    modesettingPtr ms = modesettingPTR(crtc->scrn);
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    int i;
+    uint32_t *ptr;
+    uint32_t handle = drmmode_crtc->cursor_bo->handle;
+    int ret;
+
+    /* cursor should be mapped already */
+    ptr = (uint32_t *) (drmmode_crtc->cursor_bo->ptr);
+
+    for (i = 0; i < ms->cursor_width * ms->cursor_height; i++)
+        ptr[i] = image[i];      // cpu_to_le32(image[i]);
+
+    ret =
+        drmModeSetCursor(drmmode_crtc->drmmode->fd,
+                         drmmode_crtc->mode_crtc->crtc_id, handle,
+                         ms->cursor_width, ms->cursor_height);
+    if (ret) {
+        xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+        xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+
+        cursor_info->MaxWidth = cursor_info->MaxHeight = 0;
+        drmmode_crtc->drmmode->sw_cursor = TRUE;
+        /* fallback to swcursor */
+    }
 }
 
-
 static void
-drmmode_hide_cursor (xf86CrtcPtr crtc)
+drmmode_hide_cursor(xf86CrtcPtr crtc)
 {
-	modesettingPtr ms = modesettingPTR(crtc->scrn);
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    modesettingPtr ms = modesettingPTR(crtc->scrn);
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
 
-	drmModeSetCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, 0,
-			 ms->cursor_width, ms->cursor_height);
+    drmModeSetCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, 0,
+                     ms->cursor_width, ms->cursor_height);
 
 }
 
 static void
-drmmode_show_cursor (xf86CrtcPtr crtc)
+drmmode_show_cursor(xf86CrtcPtr crtc)
 {
-	modesettingPtr ms = modesettingPTR(crtc->scrn);
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
-	uint32_t handle = drmmode_crtc->cursor_bo->handle;
-       static Bool use_set_cursor2 = TRUE;
-
-       if (use_set_cursor2) {
-               xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
-               CursorPtr cursor = xf86_config->cursor;
-               int ret;
-               ret = drmModeSetCursor2(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, handle, ms->cursor_width, ms->cursor_height, cursor->bits->xhot, cursor->bits->yhot);
-               if (ret == -EINVAL)
-                       use_set_cursor2 = FALSE;
-               else
-                       return;
-       }
-
-	drmModeSetCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, handle,
-			 ms->cursor_width, ms->cursor_height);
+    modesettingPtr ms = modesettingPTR(crtc->scrn);
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    uint32_t handle = drmmode_crtc->cursor_bo->handle;
+    static Bool use_set_cursor2 = TRUE;
+
+    if (use_set_cursor2) {
+        xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+        CursorPtr cursor = xf86_config->cursor;
+        int ret;
+
+        ret =
+            drmModeSetCursor2(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
+                              handle, ms->cursor_width, ms->cursor_height,
+                              cursor->bits->xhot, cursor->bits->yhot);
+        if (ret == -EINVAL)
+            use_set_cursor2 = FALSE;
+        else
+            return;
+    }
+
+    drmModeSetCursor(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id, handle,
+                     ms->cursor_width, ms->cursor_height);
 }
 
 static void
-drmmode_crtc_gamma_set(xf86CrtcPtr crtc, uint16_t *red, uint16_t *green,
-                      uint16_t *blue, int size)
+drmmode_crtc_gamma_set(xf86CrtcPtr crtc, uint16_t * red, uint16_t * green,
+                       uint16_t * blue, int size)
 {
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
 
-	drmModeCrtcSetGamma(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
-			    size, red, green, blue);
+    drmModeCrtcSetGamma(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
+                        size, red, green, blue);
 }
 
 static Bool
 drmmode_set_scanout_pixmap(xf86CrtcPtr crtc, PixmapPtr ppix)
 {
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
-	msPixmapPrivPtr ppriv;
-	void *ptr;
-
-	if (!ppix) {
-		if (crtc->randr_crtc->scanout_pixmap) {
-    			ppriv = msGetPixmapPriv(drmmode, crtc->randr_crtc->scanout_pixmap);
-			drmModeRmFB(drmmode->fd, ppriv->fb_id);
-		}
-		if (drmmode_crtc->slave_damage) {
-			DamageUnregister(drmmode_crtc->slave_damage);
-			drmmode_crtc->slave_damage = NULL;
-		}
-		return TRUE;
-	}
-
-	ppriv = msGetPixmapPriv(drmmode, ppix);
-	if (!drmmode_crtc->slave_damage) {
-		drmmode_crtc->slave_damage = DamageCreate(NULL, NULL,
-							  DamageReportNone,
-							  TRUE,
-							  crtc->randr_crtc->pScreen,
-							  NULL);
-	}
-	ptr = drmmode_map_slave_bo(drmmode, ppriv);
-	ppix->devPrivate.ptr = ptr;
-	DamageRegister(&ppix->drawable, drmmode_crtc->slave_damage);
-
-	if (ppriv->fb_id == 0) {
-                drmModeAddFB(drmmode->fd, ppix->drawable.width,
-                             ppix->drawable.height,
-                             ppix->drawable.depth,
-                             ppix->drawable.bitsPerPixel,
-                             ppix->devKind,
-                             ppriv->backing_bo->handle,
-                             &ppriv->fb_id);
-	}
-	return TRUE;
+    drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    msPixmapPrivPtr ppriv;
+    void *ptr;
+
+    if (!ppix) {
+        if (crtc->randr_crtc->scanout_pixmap) {
+            ppriv = msGetPixmapPriv(drmmode, crtc->randr_crtc->scanout_pixmap);
+            drmModeRmFB(drmmode->fd, ppriv->fb_id);
+        }
+        if (drmmode_crtc->slave_damage) {
+            DamageUnregister(drmmode_crtc->slave_damage);
+            drmmode_crtc->slave_damage = NULL;
+        }
+        return TRUE;
+    }
+
+    ppriv = msGetPixmapPriv(drmmode, ppix);
+    if (!drmmode_crtc->slave_damage) {
+        drmmode_crtc->slave_damage = DamageCreate(NULL, NULL,
+                                                  DamageReportNone,
+                                                  TRUE,
+                                                  crtc->randr_crtc->pScreen,
+                                                  NULL);
+    }
+    ptr = drmmode_map_slave_bo(drmmode, ppriv);
+    ppix->devPrivate.ptr = ptr;
+    DamageRegister(&ppix->drawable, drmmode_crtc->slave_damage);
+
+    if (ppriv->fb_id == 0) {
+        drmModeAddFB(drmmode->fd, ppix->drawable.width,
+                     ppix->drawable.height,
+                     ppix->drawable.depth,
+                     ppix->drawable.bitsPerPixel,
+                     ppix->devKind, ppriv->backing_bo->handle, &ppriv->fb_id);
+    }
+    return TRUE;
 }
 
-static void *drmmode_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
+static void *
+drmmode_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
 {
-	return NULL;
+    return NULL;
 }
 
-static PixmapPtr drmmode_shadow_create(xf86CrtcPtr crtc, void *data, int width,
-				       int height)
+static PixmapPtr
+drmmode_shadow_create(xf86CrtcPtr crtc, void *data, int width, int height)
 {
-	return NULL;
+    return NULL;
 }
 
 static const xf86CrtcFuncsRec drmmode_crtc_funcs = {
@@ -568,7 +576,7 @@ static const xf86CrtcFuncsRec drmmode_crtc_funcs = {
     .load_cursor_argb = drmmode_load_cursor_argb,
 
     .gamma_set = drmmode_crtc_gamma_set,
-    .destroy = NULL, /* XXX */
+    .destroy = NULL,            /* XXX */
     .set_scanout_pixmap = drmmode_set_scanout_pixmap,
     .shadow_allocate = drmmode_shadow_allocate,
     .shadow_create = drmmode_shadow_create,
@@ -577,222 +585,224 @@ static const xf86CrtcFuncsRec drmmode_crtc_funcs = {
 static void
 drmmode_crtc_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int num)
 {
-	xf86CrtcPtr crtc;
-	drmmode_crtc_private_ptr drmmode_crtc;
-
-	crtc = xf86CrtcCreate(pScrn, &drmmode_crtc_funcs);
-	if (crtc == NULL)
-		return;
-
-	drmmode_crtc = xnfcalloc(sizeof(drmmode_crtc_private_rec), 1);
-	drmmode_crtc->mode_crtc = drmModeGetCrtc(drmmode->fd, drmmode->mode_res->crtcs[num]);
-	drmmode_crtc->drmmode = drmmode;
-	crtc->driver_private = drmmode_crtc;
+    xf86CrtcPtr crtc;
+    drmmode_crtc_private_ptr drmmode_crtc;
+
+    crtc = xf86CrtcCreate(pScrn, &drmmode_crtc_funcs);
+    if (crtc == NULL)
+        return;
+
+    drmmode_crtc = xnfcalloc(sizeof(drmmode_crtc_private_rec), 1);
+    drmmode_crtc->mode_crtc =
+        drmModeGetCrtc(drmmode->fd, drmmode->mode_res->crtcs[num]);
+    drmmode_crtc->drmmode = drmmode;
+    crtc->driver_private = drmmode_crtc;
 }
 
 static xf86OutputStatus
 drmmode_output_detect(xf86OutputPtr output)
 {
-	/* go to the hw and retrieve a new output struct */
-	drmmode_output_private_ptr drmmode_output = output->driver_private;
-	drmmode_ptr drmmode = drmmode_output->drmmode;
-	xf86OutputStatus status;
-	drmModeFreeConnector(drmmode_output->mode_output);
-
-	drmmode_output->mode_output = drmModeGetConnector(drmmode->fd, drmmode_output->output_id);
-	if (!drmmode_output->mode_output)
-		return XF86OutputStatusDisconnected;
-
-	switch (drmmode_output->mode_output->connection) {
-	case DRM_MODE_CONNECTED:
-		status = XF86OutputStatusConnected;
-		break;
-	case DRM_MODE_DISCONNECTED:
-		status = XF86OutputStatusDisconnected;
-		break;
-	default:
-	case DRM_MODE_UNKNOWNCONNECTION:
-		status = XF86OutputStatusUnknown;
-		break;
-	}
-	return status;
+    /* go to the hw and retrieve a new output struct */
+    drmmode_output_private_ptr drmmode_output = output->driver_private;
+    drmmode_ptr drmmode = drmmode_output->drmmode;
+    xf86OutputStatus status;
+
+    drmModeFreeConnector(drmmode_output->mode_output);
+
+    drmmode_output->mode_output =
+        drmModeGetConnector(drmmode->fd, drmmode_output->output_id);
+    if (!drmmode_output->mode_output)
+        return XF86OutputStatusDisconnected;
+
+    switch (drmmode_output->mode_output->connection) {
+    case DRM_MODE_CONNECTED:
+        status = XF86OutputStatusConnected;
+        break;
+    case DRM_MODE_DISCONNECTED:
+        status = XF86OutputStatusDisconnected;
+        break;
+    default:
+    case DRM_MODE_UNKNOWNCONNECTION:
+        status = XF86OutputStatusUnknown;
+        break;
+    }
+    return status;
 }
 
 static Bool
 drmmode_output_mode_valid(xf86OutputPtr output, DisplayModePtr pModes)
 {
-	return MODE_OK;
+    return MODE_OK;
 }
 
 static Bool
 has_panel_fitter(xf86OutputPtr output)
 {
-	drmmode_output_private_ptr drmmode_output = output->driver_private;
-	drmModeConnectorPtr koutput = drmmode_output->mode_output;
-	drmmode_ptr drmmode = drmmode_output->drmmode;
-	int i;
-
-	/* Presume that if the output supports scaling, then we have a
-	 * panel fitter capable of adjust any mode to suit.
-	 */
-	for (i = 0; i < koutput->count_props; i++) {
-		drmModePropertyPtr props;
-		Bool found = FALSE;
-
-		props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
-		if (props) {
-			found = strcmp(props->name, "scaling mode") == 0;
-			drmModeFreeProperty(props);
-		}
-
-		if (found)
-			return TRUE;
-	}
-
-	return FALSE;
+    drmmode_output_private_ptr drmmode_output = output->driver_private;
+    drmModeConnectorPtr koutput = drmmode_output->mode_output;
+    drmmode_ptr drmmode = drmmode_output->drmmode;
+    int i;
+
+    /* Presume that if the output supports scaling, then we have a
+     * panel fitter capable of adjust any mode to suit.
+     */
+    for (i = 0; i < koutput->count_props; i++) {
+        drmModePropertyPtr props;
+        Bool found = FALSE;
+
+        props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
+        if (props) {
+            found = strcmp(props->name, "scaling mode") == 0;
+            drmModeFreeProperty(props);
+        }
+
+        if (found)
+            return TRUE;
+    }
+
+    return FALSE;
 }
 
 static DisplayModePtr
-drmmode_output_add_gtf_modes(xf86OutputPtr output,
-			     DisplayModePtr Modes)
+drmmode_output_add_gtf_modes(xf86OutputPtr output, DisplayModePtr Modes)
 {
-	xf86MonPtr mon = output->MonInfo;
-	DisplayModePtr i, m, preferred = NULL;
-	int max_x = 0, max_y = 0;
-	float max_vrefresh = 0.0;
-
-	if (mon && GTF_SUPPORTED(mon->features.msc))
-		return Modes;
-
-	if (!has_panel_fitter(output))
-		return Modes;
-
-	for (m = Modes; m; m = m->next) {
-		if (m->type & M_T_PREFERRED)
-			preferred = m;
-		max_x = max(max_x, m->HDisplay);
-		max_y = max(max_y, m->VDisplay);
-		max_vrefresh = max(max_vrefresh, xf86ModeVRefresh(m));
-	}
-
-	max_vrefresh = max(max_vrefresh, 60.0);
-	max_vrefresh *= (1 + SYNC_TOLERANCE);
-
-	m = xf86GetDefaultModes();
-	xf86ValidateModesSize(output->scrn, m, max_x, max_y, 0);
-
-	for (i = m; i; i = i->next) {
-		if (xf86ModeVRefresh(i) > max_vrefresh)
-			i->status = MODE_VSYNC;
-		if (preferred &&
-		    i->HDisplay >= preferred->HDisplay &&
-		    i->VDisplay >= preferred->VDisplay &&
-		    xf86ModeVRefresh(i) >= xf86ModeVRefresh(preferred))
-			i->status = MODE_VSYNC;
-	}
-
-	xf86PruneInvalidModes(output->scrn, &m, FALSE);
-
-	return xf86ModesAdd(Modes, m);
+    xf86MonPtr mon = output->MonInfo;
+    DisplayModePtr i, m, preferred = NULL;
+    int max_x = 0, max_y = 0;
+    float max_vrefresh = 0.0;
+
+    if (mon && GTF_SUPPORTED(mon->features.msc))
+        return Modes;
+
+    if (!has_panel_fitter(output))
+        return Modes;
+
+    for (m = Modes; m; m = m->next) {
+        if (m->type & M_T_PREFERRED)
+            preferred = m;
+        max_x = max(max_x, m->HDisplay);
+        max_y = max(max_y, m->VDisplay);
+        max_vrefresh = max(max_vrefresh, xf86ModeVRefresh(m));
+    }
+
+    max_vrefresh = max(max_vrefresh, 60.0);
+    max_vrefresh *= (1 + SYNC_TOLERANCE);
+
+    m = xf86GetDefaultModes();
+    xf86ValidateModesSize(output->scrn, m, max_x, max_y, 0);
+
+    for (i = m; i; i = i->next) {
+        if (xf86ModeVRefresh(i) > max_vrefresh)
+            i->status = MODE_VSYNC;
+        if (preferred &&
+            i->HDisplay >= preferred->HDisplay &&
+            i->VDisplay >= preferred->VDisplay &&
+            xf86ModeVRefresh(i) >= xf86ModeVRefresh(preferred))
+            i->status = MODE_VSYNC;
+    }
+
+    xf86PruneInvalidModes(output->scrn, &m, FALSE);
+
+    return xf86ModesAdd(Modes, m);
 }
 
 static DisplayModePtr
 drmmode_output_get_modes(xf86OutputPtr output)
 {
-	drmmode_output_private_ptr drmmode_output = output->driver_private;
-	drmModeConnectorPtr koutput = drmmode_output->mode_output;
-	drmmode_ptr drmmode = drmmode_output->drmmode;
-	int i;
-	DisplayModePtr Modes = NULL, Mode;
-	drmModePropertyPtr props;
-	xf86MonPtr mon = NULL;
-
-	if (!koutput)
-		return NULL;
-
-	/* look for an EDID property */
-	for (i = 0; i < koutput->count_props; i++) {
-		props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
-		if (props && (props->flags & DRM_MODE_PROP_BLOB)) {
-			if (!strcmp(props->name, "EDID")) {
-				if (drmmode_output->edid_blob)
-					drmModeFreePropertyBlob(drmmode_output->edid_blob);
-				drmmode_output->edid_blob = drmModeGetPropertyBlob(drmmode->fd, koutput->prop_values[i]);
-			}
-			drmModeFreeProperty(props);
-		}
-	}
-
-	if (drmmode_output->edid_blob) {
-		mon = xf86InterpretEDID(output->scrn->scrnIndex,
-					drmmode_output->edid_blob->data);
-		if (mon && drmmode_output->edid_blob->length > 128)
-			mon->flags |= MONITOR_EDID_COMPLETE_RAWDATA;
-	}
-	xf86OutputSetEDID(output, mon);
-
-	/* modes should already be available */
-	for (i = 0; i < koutput->count_modes; i++) {
-		Mode = xnfalloc(sizeof(DisplayModeRec));
-
-		drmmode_ConvertFromKMode(output->scrn, &koutput->modes[i], Mode);
-		Modes = xf86ModesAdd(Modes, Mode);
-
-	}
-
-	return drmmode_output_add_gtf_modes(output, Modes);
+    drmmode_output_private_ptr drmmode_output = output->driver_private;
+    drmModeConnectorPtr koutput = drmmode_output->mode_output;
+    drmmode_ptr drmmode = drmmode_output->drmmode;
+    int i;
+    DisplayModePtr Modes = NULL, Mode;
+    drmModePropertyPtr props;
+    xf86MonPtr mon = NULL;
+
+    if (!koutput)
+        return NULL;
+
+    /* look for an EDID property */
+    for (i = 0; i < koutput->count_props; i++) {
+        props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
+        if (props && (props->flags & DRM_MODE_PROP_BLOB)) {
+            if (!strcmp(props->name, "EDID")) {
+                if (drmmode_output->edid_blob)
+                    drmModeFreePropertyBlob(drmmode_output->edid_blob);
+                drmmode_output->edid_blob =
+                    drmModeGetPropertyBlob(drmmode->fd,
+                                           koutput->prop_values[i]);
+            }
+            drmModeFreeProperty(props);
+        }
+    }
+
+    if (drmmode_output->edid_blob) {
+        mon = xf86InterpretEDID(output->scrn->scrnIndex,
+                                drmmode_output->edid_blob->data);
+        if (mon && drmmode_output->edid_blob->length > 128)
+            mon->flags |= MONITOR_EDID_COMPLETE_RAWDATA;
+    }
+    xf86OutputSetEDID(output, mon);
+
+    /* modes should already be available */
+    for (i = 0; i < koutput->count_modes; i++) {
+        Mode = xnfalloc(sizeof(DisplayModeRec));
+
+        drmmode_ConvertFromKMode(output->scrn, &koutput->modes[i], Mode);
+        Modes = xf86ModesAdd(Modes, Mode);
+
+    }
+
+    return drmmode_output_add_gtf_modes(output, Modes);
 }
 
 static void
 drmmode_output_destroy(xf86OutputPtr output)
 {
-	drmmode_output_private_ptr drmmode_output = output->driver_private;
-	int i;
-
-	if (drmmode_output->edid_blob)
-		drmModeFreePropertyBlob(drmmode_output->edid_blob);
-	for (i = 0; i < drmmode_output->num_props; i++) {
-		drmModeFreeProperty(drmmode_output->props[i].mode_prop);
-		free(drmmode_output->props[i].atoms);
-	}
-	free(drmmode_output->props);
-	for (i = 0; i < drmmode_output->mode_output->count_encoders; i++) {
-		drmModeFreeEncoder(drmmode_output->mode_encoders[i]);
-	}
-	free(drmmode_output->mode_encoders);
-	drmModeFreeConnector(drmmode_output->mode_output);
-	free(drmmode_output);
-	output->driver_private = NULL;
+    drmmode_output_private_ptr drmmode_output = output->driver_private;
+    int i;
+
+    if (drmmode_output->edid_blob)
+        drmModeFreePropertyBlob(drmmode_output->edid_blob);
+    for (i = 0; i < drmmode_output->num_props; i++) {
+        drmModeFreeProperty(drmmode_output->props[i].mode_prop);
+        free(drmmode_output->props[i].atoms);
+    }
+    free(drmmode_output->props);
+    for (i = 0; i < drmmode_output->mode_output->count_encoders; i++) {
+        drmModeFreeEncoder(drmmode_output->mode_encoders[i]);
+    }
+    free(drmmode_output->mode_encoders);
+    drmModeFreeConnector(drmmode_output->mode_output);
+    free(drmmode_output);
+    output->driver_private = NULL;
 }
 
 static void
 drmmode_output_dpms(xf86OutputPtr output, int mode)
 {
-	drmmode_output_private_ptr drmmode_output = output->driver_private;
-	drmModeConnectorPtr koutput = drmmode_output->mode_output;
-	drmmode_ptr drmmode = drmmode_output->drmmode;
+    drmmode_output_private_ptr drmmode_output = output->driver_private;
+    drmModeConnectorPtr koutput = drmmode_output->mode_output;
+    drmmode_ptr drmmode = drmmode_output->drmmode;
 
-	if (!koutput)
-		return;
+    if (!koutput)
+        return;
 
-	drmModeConnectorSetProperty(drmmode->fd, koutput->connector_id,
-				    drmmode_output->dpms_enum_id, mode);
-	return;
+    drmModeConnectorSetProperty(drmmode->fd, koutput->connector_id,
+                                drmmode_output->dpms_enum_id, mode);
+    return;
 }
 
-
 static Bool
 drmmode_property_ignore(drmModePropertyPtr prop)
 {
     if (!prop)
-	return TRUE;
+        return TRUE;
     /* ignore blob prop */
     if (prop->flags & DRM_MODE_PROP_BLOB)
-	return TRUE;
+        return TRUE;
     /* ignore standard property */
-    if (!strcmp(prop->name, "EDID") ||
-	    !strcmp(prop->name, "DPMS"))
-	return TRUE;
+    if (!strcmp(prop->name, "EDID") || !strcmp(prop->name, "DPMS"))
+        return TRUE;
 
     return FALSE;
 }
@@ -806,128 +816,143 @@ drmmode_output_create_resources(xf86OutputPtr output)
     drmModePropertyPtr drmmode_prop;
     int i, j, err;
 
-    drmmode_output->props = calloc(mode_output->count_props, sizeof(drmmode_prop_rec));
+    drmmode_output->props =
+        calloc(mode_output->count_props, sizeof(drmmode_prop_rec));
     if (!drmmode_output->props)
-	return;
-    
+        return;
+
     drmmode_output->num_props = 0;
     for (i = 0, j = 0; i < mode_output->count_props; i++) {
-	drmmode_prop = drmModeGetProperty(drmmode->fd, mode_output->props[i]);
-	if (drmmode_property_ignore(drmmode_prop)) {
-	    drmModeFreeProperty(drmmode_prop);
-	    continue;
-	}
-	drmmode_output->props[j].mode_prop = drmmode_prop;
-	drmmode_output->props[j].value = mode_output->prop_values[i];
-	drmmode_output->num_props++;
-	j++;
+        drmmode_prop = drmModeGetProperty(drmmode->fd, mode_output->props[i]);
+        if (drmmode_property_ignore(drmmode_prop)) {
+            drmModeFreeProperty(drmmode_prop);
+            continue;
+        }
+        drmmode_output->props[j].mode_prop = drmmode_prop;
+        drmmode_output->props[j].value = mode_output->prop_values[i];
+        drmmode_output->num_props++;
+        j++;
     }
 
     for (i = 0; i < drmmode_output->num_props; i++) {
-	drmmode_prop_ptr p = &drmmode_output->props[i];
-	drmmode_prop = p->mode_prop;
-
-	if (drmmode_prop->flags & DRM_MODE_PROP_RANGE) {
-	    INT32 prop_range[2];
-	    INT32 value = p->value;
-
-	    p->num_atoms = 1;
-	    p->atoms = calloc(p->num_atoms, sizeof(Atom));
-	    if (!p->atoms)
-		continue;
-	    p->atoms[0] = MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE);
-	    prop_range[0] = drmmode_prop->values[0];
-	    prop_range[1] = drmmode_prop->values[1];
-	    err = RRConfigureOutputProperty(output->randr_output, p->atoms[0],
-		    FALSE, TRUE,
-		    drmmode_prop->flags & DRM_MODE_PROP_IMMUTABLE ? TRUE : FALSE,
-		    2, prop_range);
-	    if (err != 0) {
-		xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
-			"RRConfigureOutputProperty error, %d\n", err);
-	    }
-	    err = RRChangeOutputProperty(output->randr_output, p->atoms[0],
-		    XA_INTEGER, 32, PropModeReplace, 1, &value, FALSE, TRUE);
-	    if (err != 0) {
-		xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
-			"RRChangeOutputProperty error, %d\n", err);
-	    }
-	} else if (drmmode_prop->flags & DRM_MODE_PROP_ENUM) {
-	    p->num_atoms = drmmode_prop->count_enums + 1;
-	    p->atoms = calloc(p->num_atoms, sizeof(Atom));
-	    if (!p->atoms)
-		continue;
-	    p->atoms[0] = MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE);
-	    for (j = 1; j <= drmmode_prop->count_enums; j++) {
-		struct drm_mode_property_enum *e = &drmmode_prop->enums[j-1];
-		p->atoms[j] = MakeAtom(e->name, strlen(e->name), TRUE);
-	    }
-	    err = RRConfigureOutputProperty(output->randr_output, p->atoms[0],
-		    FALSE, FALSE,
-		    drmmode_prop->flags & DRM_MODE_PROP_IMMUTABLE ? TRUE : FALSE,
-		    p->num_atoms - 1, (INT32 *)&p->atoms[1]);
-	    if (err != 0) {
-		xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
-			"RRConfigureOutputProperty error, %d\n", err);
-	    }
-	    for (j = 0; j < drmmode_prop->count_enums; j++)
-		if (drmmode_prop->enums[j].value == p->value)
-		    break;
-	    /* there's always a matching value */
-	    err = RRChangeOutputProperty(output->randr_output, p->atoms[0],
-		    XA_ATOM, 32, PropModeReplace, 1, &p->atoms[j+1], FALSE, TRUE);
-	    if (err != 0) {
-		xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
-			"RRChangeOutputProperty error, %d\n", err);
-	    }
-	}
+        drmmode_prop_ptr p = &drmmode_output->props[i];
+
+        drmmode_prop = p->mode_prop;
+
+        if (drmmode_prop->flags & DRM_MODE_PROP_RANGE) {
+            INT32 prop_range[2];
+            INT32 value = p->value;
+
+            p->num_atoms = 1;
+            p->atoms = calloc(p->num_atoms, sizeof(Atom));
+            if (!p->atoms)
+                continue;
+            p->atoms[0] =
+                MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE);
+            prop_range[0] = drmmode_prop->values[0];
+            prop_range[1] = drmmode_prop->values[1];
+            err = RRConfigureOutputProperty(output->randr_output, p->atoms[0],
+                                            FALSE, TRUE,
+                                            drmmode_prop->
+                                            flags & DRM_MODE_PROP_IMMUTABLE ?
+                                            TRUE : FALSE, 2, prop_range);
+            if (err != 0) {
+                xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
+                           "RRConfigureOutputProperty error, %d\n", err);
+            }
+            err = RRChangeOutputProperty(output->randr_output, p->atoms[0],
+                                         XA_INTEGER, 32, PropModeReplace, 1,
+                                         &value, FALSE, TRUE);
+            if (err != 0) {
+                xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
+                           "RRChangeOutputProperty error, %d\n", err);
+            }
+        }
+        else if (drmmode_prop->flags & DRM_MODE_PROP_ENUM) {
+            p->num_atoms = drmmode_prop->count_enums + 1;
+            p->atoms = calloc(p->num_atoms, sizeof(Atom));
+            if (!p->atoms)
+                continue;
+            p->atoms[0] =
+                MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE);
+            for (j = 1; j <= drmmode_prop->count_enums; j++) {
+                struct drm_mode_property_enum *e = &drmmode_prop->enums[j - 1];
+
+                p->atoms[j] = MakeAtom(e->name, strlen(e->name), TRUE);
+            }
+            err = RRConfigureOutputProperty(output->randr_output, p->atoms[0],
+                                            FALSE, FALSE,
+                                            drmmode_prop->
+                                            flags & DRM_MODE_PROP_IMMUTABLE ?
+                                            TRUE : FALSE, p->num_atoms - 1,
+                                            (INT32 *) &p->atoms[1]);
+            if (err != 0) {
+                xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
+                           "RRConfigureOutputProperty error, %d\n", err);
+            }
+            for (j = 0; j < drmmode_prop->count_enums; j++)
+                if (drmmode_prop->enums[j].value == p->value)
+                    break;
+            /* there's always a matching value */
+            err = RRChangeOutputProperty(output->randr_output, p->atoms[0],
+                                         XA_ATOM, 32, PropModeReplace, 1,
+                                         &p->atoms[j + 1], FALSE, TRUE);
+            if (err != 0) {
+                xf86DrvMsg(output->scrn->scrnIndex, X_ERROR,
+                           "RRChangeOutputProperty error, %d\n", err);
+            }
+        }
     }
 }
 
 static Bool
 drmmode_output_set_property(xf86OutputPtr output, Atom property,
-		RRPropertyValuePtr value)
+                            RRPropertyValuePtr value)
 {
     drmmode_output_private_ptr drmmode_output = output->driver_private;
     drmmode_ptr drmmode = drmmode_output->drmmode;
     int i;
 
     for (i = 0; i < drmmode_output->num_props; i++) {
-	drmmode_prop_ptr p = &drmmode_output->props[i];
-
-	if (p->atoms[0] != property)
-	    continue;
-
-	if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) {
-	    uint32_t val;
-
-	    if (value->type != XA_INTEGER || value->format != 32 ||
-		    value->size != 1)
-		return FALSE;
-	    val = *(uint32_t *)value->data;
-
-	    drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id,
-		    p->mode_prop->prop_id, (uint64_t)val);
-	    return TRUE;
-	} else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) {
-	    Atom	atom;
-	    const char	*name;
-	    int		j;
-
-	    if (value->type != XA_ATOM || value->format != 32 || value->size != 1)
-		return FALSE;
-	    memcpy(&atom, value->data, 4);
-	    name = NameForAtom(atom);
-
-	    /* search for matching name string, then set its value down */
-	    for (j = 0; j < p->mode_prop->count_enums; j++) {
-		if (!strcmp(p->mode_prop->enums[j].name, name)) {
-		    drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id,
-			    p->mode_prop->prop_id, p->mode_prop->enums[j].value);
-		    return TRUE;
-		}
-	    }
-	}
+        drmmode_prop_ptr p = &drmmode_output->props[i];
+
+        if (p->atoms[0] != property)
+            continue;
+
+        if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) {
+            uint32_t val;
+
+            if (value->type != XA_INTEGER || value->format != 32 ||
+                value->size != 1)
+                return FALSE;
+            val = *(uint32_t *) value->data;
+
+            drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id,
+                                        p->mode_prop->prop_id, (uint64_t) val);
+            return TRUE;
+        }
+        else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) {
+            Atom atom;
+            const char *name;
+            int j;
+
+            if (value->type != XA_ATOM || value->format != 32 ||
+                value->size != 1)
+                return FALSE;
+            memcpy(&atom, value->data, 4);
+            name = NameForAtom(atom);
+
+            /* search for matching name string, then set its value down */
+            for (j = 0; j < p->mode_prop->count_enums; j++) {
+                if (!strcmp(p->mode_prop->enums[j].name, name)) {
+                    drmModeConnectorSetProperty(drmmode->fd,
+                                                drmmode_output->output_id,
+                                                p->mode_prop->prop_id,
+                                                p->mode_prop->enums[j].value);
+                    return TRUE;
+                }
+            }
+        }
     }
 
     return TRUE;
@@ -951,402 +976,420 @@ static const xf86OutputFuncsRec drmmode_output_funcs = {
     .destroy = drmmode_output_destroy
 };
 
-static int subpixel_conv_table[7] = { 0, SubPixelUnknown,
-				      SubPixelHorizontalRGB,
-				      SubPixelHorizontalBGR,
-				      SubPixelVerticalRGB,
-				      SubPixelVerticalBGR,
-				      SubPixelNone };
-
-static const char * const output_names[] = { "None",
-					     "VGA",
-					     "DVI",
-					     "DVI",
-					     "DVI",
-					     "Composite",
-					     "S-video",
-					     "LVDS",
-					     "CTV",
-					     "DIN",
-					     "DisplayPort",
-					     "HDMI",
-					     "HDMI",
-					     "TV",
-					     "eDP",
-					     "Virtual",
-					     "DSI",
+static int subpixel_conv_table[7] = {
+    0,
+    SubPixelUnknown,
+    SubPixelHorizontalRGB,
+    SubPixelHorizontalBGR,
+    SubPixelVerticalRGB,
+    SubPixelVerticalBGR,
+    SubPixelNone
+};
+
+static const char *const output_names[] = {
+    "None",
+    "VGA",
+    "DVI",
+    "DVI",
+    "DVI",
+    "Composite",
+    "S-video",
+    "LVDS",
+    "CTV",
+    "DIN",
+    "DisplayPort",
+    "HDMI",
+    "HDMI",
+    "TV",
+    "eDP",
+    "Virtual",
+    "DSI",
 };
 
 static void
-drmmode_output_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int num, int *num_dvi, int *num_hdmi)
+drmmode_output_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int num,
+                    int *num_dvi, int *num_hdmi)
 {
-	xf86OutputPtr output;
-	drmModeConnectorPtr koutput;
-	drmModeEncoderPtr *kencoders = NULL;
-	drmmode_output_private_ptr drmmode_output;
-	drmModePropertyPtr props;
-	char name[32];
-	int i;
-
-	koutput = drmModeGetConnector(drmmode->fd, drmmode->mode_res->connectors[num]);
-	if (!koutput)
-		return;
-
-	kencoders = calloc(sizeof(drmModeEncoderPtr), koutput->count_encoders);
-	if (!kencoders) {
-		goto out_free_encoders;
-	}
-
-	for (i = 0; i < koutput->count_encoders; i++) {
-		kencoders[i] = drmModeGetEncoder(drmmode->fd, koutput->encoders[i]);
-		if (!kencoders[i]) {
-			goto out_free_encoders;
-		}
-	}
-
-	/* need to do smart conversion here for compat with non-kms ATI driver */
-	if (koutput->connector_type >= MS_ARRAY_SIZE(output_names))
-		snprintf(name, 32, "Unknown-%d", koutput->connector_type_id - 1);
-	else if (pScrn->is_gpu)
-		snprintf(name, 32, "%s-%d-%d", output_names[koutput->connector_type], pScrn->scrnIndex - GPU_SCREEN_OFFSET + 1, koutput->connector_type_id - 1);
-	else
-		snprintf(name, 32, "%s-%d", output_names[koutput->connector_type], koutput->connector_type_id - 1);
-
-	output = xf86OutputCreate (pScrn, &drmmode_output_funcs, name);
-	if (!output) {
-		goto out_free_encoders;
-	}
-
-	drmmode_output = calloc(sizeof(drmmode_output_private_rec), 1);
-	if (!drmmode_output) {
-		xf86OutputDestroy(output);
-		goto out_free_encoders;
-	}
-
-	drmmode_output->output_id = drmmode->mode_res->connectors[num];
-	drmmode_output->mode_output = koutput;
-	drmmode_output->mode_encoders = kencoders;
-	drmmode_output->drmmode = drmmode;
-	output->mm_width = koutput->mmWidth;
-	output->mm_height = koutput->mmHeight;
-
-	output->subpixel_order = subpixel_conv_table[koutput->subpixel];
-	output->interlaceAllowed = TRUE;
-	output->doubleScanAllowed = TRUE;
-	output->driver_private = drmmode_output;
-	
-	output->possible_crtcs = 0x7f;
-	for (i = 0; i < koutput->count_encoders; i++) {
-		output->possible_crtcs &= kencoders[i]->possible_crtcs;
-	}
-	/* work out the possible clones later */
-	output->possible_clones = 0;
-
-	for (i = 0; i < koutput->count_props; i++) {
-		props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
-		if (props && (props->flags & DRM_MODE_PROP_ENUM)) {
-			if (!strcmp(props->name, "DPMS")) {
-				drmmode_output->dpms_enum_id = koutput->props[i];
-				drmModeFreeProperty(props);
-				break;
-			}
-			drmModeFreeProperty(props);
-		}
-	}
-
-	return;
-out_free_encoders:
-	if (kencoders){
-		for (i = 0; i < koutput->count_encoders; i++)
-			drmModeFreeEncoder(kencoders[i]);
-		free(kencoders);
-	}
-	drmModeFreeConnector(koutput);
-	
+    xf86OutputPtr output;
+    drmModeConnectorPtr koutput;
+    drmModeEncoderPtr *kencoders = NULL;
+    drmmode_output_private_ptr drmmode_output;
+    drmModePropertyPtr props;
+    char name[32];
+    int i;
+
+    koutput =
+        drmModeGetConnector(drmmode->fd, drmmode->mode_res->connectors[num]);
+    if (!koutput)
+        return;
+
+    kencoders = calloc(sizeof(drmModeEncoderPtr), koutput->count_encoders);
+    if (!kencoders) {
+        goto out_free_encoders;
+    }
+
+    for (i = 0; i < koutput->count_encoders; i++) {
+        kencoders[i] = drmModeGetEncoder(drmmode->fd, koutput->encoders[i]);
+        if (!kencoders[i]) {
+            goto out_free_encoders;
+        }
+    }
+
+    /* need to do smart conversion here for compat with non-kms ATI driver */
+    if (koutput->connector_type >= MS_ARRAY_SIZE(output_names))
+        snprintf(name, 32, "Unknown-%d", koutput->connector_type_id - 1);
+    else if (pScrn->is_gpu)
+        snprintf(name, 32, "%s-%d-%d", output_names[koutput->connector_type],
+                 pScrn->scrnIndex - GPU_SCREEN_OFFSET + 1,
+                 koutput->connector_type_id - 1);
+    else
+        snprintf(name, 32, "%s-%d", output_names[koutput->connector_type],
+                 koutput->connector_type_id - 1);
+
+    output = xf86OutputCreate(pScrn, &drmmode_output_funcs, name);
+    if (!output) {
+        goto out_free_encoders;
+    }
+
+    drmmode_output = calloc(sizeof(drmmode_output_private_rec), 1);
+    if (!drmmode_output) {
+        xf86OutputDestroy(output);
+        goto out_free_encoders;
+    }
+
+    drmmode_output->output_id = drmmode->mode_res->connectors[num];
+    drmmode_output->mode_output = koutput;
+    drmmode_output->mode_encoders = kencoders;
+    drmmode_output->drmmode = drmmode;
+    output->mm_width = koutput->mmWidth;
+    output->mm_height = koutput->mmHeight;
+
+    output->subpixel_order = subpixel_conv_table[koutput->subpixel];
+    output->interlaceAllowed = TRUE;
+    output->doubleScanAllowed = TRUE;
+    output->driver_private = drmmode_output;
+
+    output->possible_crtcs = 0x7f;
+    for (i = 0; i < koutput->count_encoders; i++) {
+        output->possible_crtcs &= kencoders[i]->possible_crtcs;
+    }
+    /* work out the possible clones later */
+    output->possible_clones = 0;
+
+    for (i = 0; i < koutput->count_props; i++) {
+        props = drmModeGetProperty(drmmode->fd, koutput->props[i]);
+        if (props && (props->flags & DRM_MODE_PROP_ENUM)) {
+            if (!strcmp(props->name, "DPMS")) {
+                drmmode_output->dpms_enum_id = koutput->props[i];
+                drmModeFreeProperty(props);
+                break;
+            }
+            drmModeFreeProperty(props);
+        }
+    }
+
+    return;
+ out_free_encoders:
+    if (kencoders) {
+        for (i = 0; i < koutput->count_encoders; i++)
+            drmModeFreeEncoder(kencoders[i]);
+        free(kencoders);
+    }
+    drmModeFreeConnector(koutput);
+
 }
 
-static uint32_t find_clones(ScrnInfoPtr scrn, xf86OutputPtr output)
+static uint32_t
+find_clones(ScrnInfoPtr scrn, xf86OutputPtr output)
 {
-	drmmode_output_private_ptr drmmode_output = output->driver_private, clone_drmout;
-	int i;
-	xf86OutputPtr clone_output;
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-	int index_mask = 0;
-
-	if (drmmode_output->enc_clone_mask == 0)
-		return index_mask;
-
-	for (i = 0; i < xf86_config->num_output; i++) {
-		clone_output = xf86_config->output[i];
-		clone_drmout = clone_output->driver_private;
-		if (output == clone_output)
-			continue;
-		
-		if (clone_drmout->enc_mask == 0)
-			continue;
-		if (drmmode_output->enc_clone_mask == clone_drmout->enc_mask)
-			index_mask |= (1 << i);
-	}
-	return index_mask;
+    drmmode_output_private_ptr drmmode_output =
+        output->driver_private, clone_drmout;
+    int i;
+    xf86OutputPtr clone_output;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int index_mask = 0;
+
+    if (drmmode_output->enc_clone_mask == 0)
+        return index_mask;
+
+    for (i = 0; i < xf86_config->num_output; i++) {
+        clone_output = xf86_config->output[i];
+        clone_drmout = clone_output->driver_private;
+        if (output == clone_output)
+            continue;
+
+        if (clone_drmout->enc_mask == 0)
+            continue;
+        if (drmmode_output->enc_clone_mask == clone_drmout->enc_mask)
+            index_mask |= (1 << i);
+    }
+    return index_mask;
 }
 
-
 static void
 drmmode_clones_init(ScrnInfoPtr scrn, drmmode_ptr drmmode)
 {
-	int i, j;
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-
-	for (i = 0; i < xf86_config->num_output; i++) {
-		xf86OutputPtr output = xf86_config->output[i];
-		drmmode_output_private_ptr drmmode_output;
-
-		drmmode_output = output->driver_private;
-		drmmode_output->enc_clone_mask = 0xff;
-		/* and all the possible encoder clones for this output together */
-		for (j = 0; j < drmmode_output->mode_output->count_encoders; j++)
-		{
-			int k;
-			for (k = 0; k < drmmode->mode_res->count_encoders; k++) {
-				if (drmmode->mode_res->encoders[k] == drmmode_output->mode_encoders[j]->encoder_id)
-					drmmode_output->enc_mask |= (1 << k);
-			}
-
-			drmmode_output->enc_clone_mask &= drmmode_output->mode_encoders[j]->possible_clones;
-		}
-	}
-
-	for (i = 0; i < xf86_config->num_output; i++) {
-		xf86OutputPtr output = xf86_config->output[i];
-		output->possible_clones = find_clones(scrn, output);
-	}
+    int i, j;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    for (i = 0; i < xf86_config->num_output; i++) {
+        xf86OutputPtr output = xf86_config->output[i];
+        drmmode_output_private_ptr drmmode_output;
+
+        drmmode_output = output->driver_private;
+        drmmode_output->enc_clone_mask = 0xff;
+        /* and all the possible encoder clones for this output together */
+        for (j = 0; j < drmmode_output->mode_output->count_encoders; j++) {
+            int k;
+
+            for (k = 0; k < drmmode->mode_res->count_encoders; k++) {
+                if (drmmode->mode_res->encoders[k] ==
+                    drmmode_output->mode_encoders[j]->encoder_id)
+                    drmmode_output->enc_mask |= (1 << k);
+            }
+
+            drmmode_output->enc_clone_mask &=
+                drmmode_output->mode_encoders[j]->possible_clones;
+        }
+    }
+
+    for (i = 0; i < xf86_config->num_output; i++) {
+        xf86OutputPtr output = xf86_config->output[i];
+
+        output->possible_clones = find_clones(scrn, output);
+    }
 }
 
 static Bool
-drmmode_xf86crtc_resize (ScrnInfoPtr scrn, int width, int height)
+drmmode_xf86crtc_resize(ScrnInfoPtr scrn, int width, int height)
 {
-	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
-	drmmode_crtc_private_ptr
-		    drmmode_crtc = xf86_config->crtc[0]->driver_private;
-	drmmode_ptr drmmode = drmmode_crtc->drmmode;
-	struct dumb_bo *old_front = NULL;
-	Bool	    ret;
-	ScreenPtr   screen = xf86ScrnToScreen(scrn);
-	uint32_t    old_fb_id;
-	int	    i, pitch, old_width, old_height, old_pitch;
-	int cpp = (scrn->bitsPerPixel + 7) / 8;
-	PixmapPtr ppix = screen->GetScreenPixmap(screen);
-	void *new_pixels;
-
-	if (scrn->virtualX == width && scrn->virtualY == height)
-		return TRUE;
-
-	xf86DrvMsg(scrn->scrnIndex, X_INFO,
-		   "Allocate new frame buffer %dx%d stride\n",
-		   width, height);
-
-	old_width = scrn->virtualX;
-	old_height = scrn->virtualY;
-	old_pitch = drmmode->front_bo->pitch;
-	old_fb_id = drmmode->fb_id;
-	old_front = drmmode->front_bo;
-
-	drmmode->front_bo = dumb_bo_create(drmmode->fd, width, height, scrn->bitsPerPixel);
-	if (!drmmode->front_bo)
-		goto fail;
-
-	pitch = drmmode->front_bo->pitch;
-
-	scrn->virtualX = width;
-	scrn->virtualY = height;
-	scrn->displayWidth = pitch / cpp;
-
-	ret = drmModeAddFB(drmmode->fd, width, height, scrn->depth,
-			   scrn->bitsPerPixel, pitch,
-			   drmmode->front_bo->handle,
-			   &drmmode->fb_id);
-	if (ret)
-		goto fail;
-	
-	new_pixels  = drmmode_map_front_bo(drmmode);
-	if (!new_pixels)
-		goto fail;
-
-	if (!drmmode->shadow_enable)
-		screen->ModifyPixmapHeader(ppix, width, height, -1, -1,
-					   pitch, new_pixels);
-	else {
-		void *new_shadow;
-		uint32_t size = scrn->displayWidth * scrn->virtualY *
-			((scrn->bitsPerPixel + 7) >> 3);
-		new_shadow = calloc(1, size);
-		if (new_shadow == NULL)
-			goto fail;
-		free(drmmode->shadow_fb);
-		drmmode->shadow_fb = new_shadow;
-		screen->ModifyPixmapHeader(ppix, width, height, -1, -1,
-					   pitch, drmmode->shadow_fb);
-	}
-
-	for (i = 0; i < xf86_config->num_crtc; i++) {
-		xf86CrtcPtr crtc = xf86_config->crtc[i];
-
-		if (!crtc->enabled)
-			continue;
-
-		drmmode_set_mode_major(crtc, &crtc->mode,
-				       crtc->rotation, crtc->x, crtc->y);
-	}
-
-	if (old_fb_id) {
-		drmModeRmFB(drmmode->fd, old_fb_id);
-		dumb_bo_destroy(drmmode->fd, old_front);
-	}
-
-	return TRUE;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    drmmode_crtc_private_ptr
+        drmmode_crtc = xf86_config->crtc[0]->driver_private;
+    drmmode_ptr drmmode = drmmode_crtc->drmmode;
+    struct dumb_bo *old_front = NULL;
+    Bool ret;
+    ScreenPtr screen = xf86ScrnToScreen(scrn);
+    uint32_t old_fb_id;
+    int i, pitch, old_width, old_height, old_pitch;
+    int cpp = (scrn->bitsPerPixel + 7) / 8;
+    PixmapPtr ppix = screen->GetScreenPixmap(screen);
+    void *new_pixels;
+
+    if (scrn->virtualX == width && scrn->virtualY == height)
+        return TRUE;
+
+    xf86DrvMsg(scrn->scrnIndex, X_INFO,
+               "Allocate new frame buffer %dx%d stride\n", width, height);
+
+    old_width = scrn->virtualX;
+    old_height = scrn->virtualY;
+    old_pitch = drmmode->front_bo->pitch;
+    old_fb_id = drmmode->fb_id;
+    old_front = drmmode->front_bo;
+
+    drmmode->front_bo =
+        dumb_bo_create(drmmode->fd, width, height, scrn->bitsPerPixel);
+    if (!drmmode->front_bo)
+        goto fail;
+
+    pitch = drmmode->front_bo->pitch;
+
+    scrn->virtualX = width;
+    scrn->virtualY = height;
+    scrn->displayWidth = pitch / cpp;
+
+    ret = drmModeAddFB(drmmode->fd, width, height, scrn->depth,
+                       scrn->bitsPerPixel, pitch,
+                       drmmode->front_bo->handle, &drmmode->fb_id);
+    if (ret)
+        goto fail;
+
+    new_pixels = drmmode_map_front_bo(drmmode);
+    if (!new_pixels)
+        goto fail;
+
+    if (!drmmode->shadow_enable)
+        screen->ModifyPixmapHeader(ppix, width, height, -1, -1,
+                                   pitch, new_pixels);
+    else {
+        void *new_shadow;
+        uint32_t size = scrn->displayWidth * scrn->virtualY *
+            ((scrn->bitsPerPixel + 7) >> 3);
+        new_shadow = calloc(1, size);
+        if (new_shadow == NULL)
+            goto fail;
+        free(drmmode->shadow_fb);
+        drmmode->shadow_fb = new_shadow;
+        screen->ModifyPixmapHeader(ppix, width, height, -1, -1,
+                                   pitch, drmmode->shadow_fb);
+    }
+
+    for (i = 0; i < xf86_config->num_crtc; i++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[i];
+
+        if (!crtc->enabled)
+            continue;
+
+        drmmode_set_mode_major(crtc, &crtc->mode,
+                               crtc->rotation, crtc->x, crtc->y);
+    }
+
+    if (old_fb_id) {
+        drmModeRmFB(drmmode->fd, old_fb_id);
+        dumb_bo_destroy(drmmode->fd, old_front);
+    }
+
+    return TRUE;
 
  fail:
-	if (drmmode->front_bo)
-		dumb_bo_destroy(drmmode->fd, drmmode->front_bo);
-	drmmode->front_bo = old_front;
-	scrn->virtualX = old_width;
-	scrn->virtualY = old_height;
-	scrn->displayWidth = old_pitch / cpp;
-	drmmode->fb_id = old_fb_id;
-
-	return FALSE;
+    if (drmmode->front_bo)
+        dumb_bo_destroy(drmmode->fd, drmmode->front_bo);
+    drmmode->front_bo = old_front;
+    scrn->virtualX = old_width;
+    scrn->virtualY = old_height;
+    scrn->displayWidth = old_pitch / cpp;
+    drmmode->fb_id = old_fb_id;
+
+    return FALSE;
 }
 
 static const xf86CrtcConfigFuncsRec drmmode_xf86crtc_config_funcs = {
-	drmmode_xf86crtc_resize
+    drmmode_xf86crtc_resize
 };
 
-Bool drmmode_pre_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int cpp)
+Bool
+drmmode_pre_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int cpp)
 {
-	int i, num_dvi = 0, num_hdmi = 0;
-	int ret;
-	uint64_t value = 0;
-
-	/* check for dumb capability */
-	ret = drmGetCap(drmmode->fd, DRM_CAP_DUMB_BUFFER, &value);
-	if (ret > 0 || value != 1) {
-		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "KMS doesn't support dumb interface\n");
-		return FALSE;
-	}
+    int i, num_dvi = 0, num_hdmi = 0;
+    int ret;
+    uint64_t value = 0;
+
+    /* check for dumb capability */
+    ret = drmGetCap(drmmode->fd, DRM_CAP_DUMB_BUFFER, &value);
+    if (ret > 0 || value != 1) {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                   "KMS doesn't support dumb interface\n");
+        return FALSE;
+    }
 
-	xf86CrtcConfigInit(pScrn, &drmmode_xf86crtc_config_funcs);
+    xf86CrtcConfigInit(pScrn, &drmmode_xf86crtc_config_funcs);
 
-	drmmode->scrn = pScrn;
-	drmmode->cpp = cpp;
-	drmmode->mode_res = drmModeGetResources(drmmode->fd);
-	if (!drmmode->mode_res)
-		return FALSE;
+    drmmode->scrn = pScrn;
+    drmmode->cpp = cpp;
+    drmmode->mode_res = drmModeGetResources(drmmode->fd);
+    if (!drmmode->mode_res)
+        return FALSE;
 
-	xf86CrtcSetSizeRange(pScrn, 320, 200, drmmode->mode_res->max_width, drmmode->mode_res->max_height);
-	for (i = 0; i < drmmode->mode_res->count_crtcs; i++)
-		if (!xf86IsEntityShared(pScrn->entityList[0]) || pScrn->confScreen->device->screen == i)
-			drmmode_crtc_init(pScrn, drmmode, i);
+    xf86CrtcSetSizeRange(pScrn, 320, 200, drmmode->mode_res->max_width,
+                         drmmode->mode_res->max_height);
+    for (i = 0; i < drmmode->mode_res->count_crtcs; i++)
+        if (!xf86IsEntityShared(pScrn->entityList[0]) ||
+            pScrn->confScreen->device->screen == i)
+            drmmode_crtc_init(pScrn, drmmode, i);
 
-	for (i = 0; i < drmmode->mode_res->count_connectors; i++)
-		drmmode_output_init(pScrn, drmmode, i, &num_dvi, &num_hdmi);
+    for (i = 0; i < drmmode->mode_res->count_connectors; i++)
+        drmmode_output_init(pScrn, drmmode, i, &num_dvi, &num_hdmi);
 
-	/* workout clones */
-	drmmode_clones_init(pScrn, drmmode);
+    /* workout clones */
+    drmmode_clones_init(pScrn, drmmode);
 
 #if XF86_CRTC_VERSION >= 5
-	xf86ProviderSetup(pScrn, NULL, "modesetting");
+    xf86ProviderSetup(pScrn, NULL, "modesetting");
 #endif
 
-	xf86InitialConfiguration(pScrn, TRUE);
+    xf86InitialConfiguration(pScrn, TRUE);
 
-	return TRUE;
+    return TRUE;
 }
 
-void drmmode_adjust_frame(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int x, int y)
+void
+drmmode_adjust_frame(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int x, int y)
 {
-	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);
-	xf86OutputPtr  output = config->output[config->compat_output];
-	xf86CrtcPtr	crtc = output->crtc;
-
-	if (crtc && crtc->enabled) {
-		drmmode_set_mode_major(crtc, &crtc->mode, crtc->rotation,
-				       x, y);
-	}
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    xf86OutputPtr output = config->output[config->compat_output];
+    xf86CrtcPtr crtc = output->crtc;
+
+    if (crtc && crtc->enabled) {
+        drmmode_set_mode_major(crtc, &crtc->mode, crtc->rotation, x, y);
+    }
 }
 
-Bool drmmode_set_desired_modes(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
+Bool
+drmmode_set_desired_modes(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
 {
-	xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-	int c;
-
-	for (c = 0; c < config->num_crtc; c++) {
-		xf86CrtcPtr	crtc = config->crtc[c];
-		drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-		xf86OutputPtr	output = NULL;
-		int		o;
-
-		/* Skip disabled CRTCs */
-		if (!crtc->enabled) {
-			drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
-				       0, 0, 0, NULL, 0, NULL);
-			continue;
-		}
-
-		if (config->output[config->compat_output]->crtc == crtc)
-			output = config->output[config->compat_output];
-		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, pScrn->currentMode);
-
-			if (!mode)
-				return FALSE;
-			crtc->desiredMode = *mode;
-			crtc->desiredRotation = RR_Rotate_0;
-			crtc->desiredX = 0;
-			crtc->desiredY = 0;
-		}
-
-		if (!crtc->funcs->set_mode_major(crtc, &crtc->desiredMode, crtc->desiredRotation,
-						 crtc->desiredX, crtc->desiredY))
-			return FALSE;
-	}
-	return TRUE;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+        drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+        xf86OutputPtr output = NULL;
+        int o;
+
+        /* Skip disabled CRTCs */
+        if (!crtc->enabled) {
+            drmModeSetCrtc(drmmode->fd, drmmode_crtc->mode_crtc->crtc_id,
+                           0, 0, 0, NULL, 0, NULL);
+            continue;
+        }
+
+        if (config->output[config->compat_output]->crtc == crtc)
+            output = config->output[config->compat_output];
+        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, pScrn->currentMode);
+
+            if (!mode)
+                return FALSE;
+            crtc->desiredMode = *mode;
+            crtc->desiredRotation = RR_Rotate_0;
+            crtc->desiredX = 0;
+            crtc->desiredY = 0;
+        }
+
+        if (!crtc->funcs->
+            set_mode_major(crtc, &crtc->desiredMode, crtc->desiredRotation,
+                           crtc->desiredX, crtc->desiredY))
+            return FALSE;
+    }
+    return TRUE;
 }
 
-static void drmmode_load_palette(ScrnInfoPtr pScrn, int numColors,
-                                 int *indices, LOCO *colors, VisualPtr pVisual)
+static void
+drmmode_load_palette(ScrnInfoPtr pScrn, int numColors,
+                     int *indices, LOCO * colors, VisualPtr pVisual)
 {
-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-    uint16_t       lut_r[256], lut_g[256], lut_b[256];
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    uint16_t lut_r[256], lut_g[256], lut_b[256];
     int index, j, i;
     int c;
 
     for (c = 0; c < xf86_config->num_crtc; c++) {
         xf86CrtcPtr crtc = xf86_config->crtc[c];
-	drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+        drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
 
-        for (i = 0 ; i < 256; i++) {
+        for (i = 0; i < 256; i++) {
             lut_r[i] = drmmode_crtc->lut_r[i] << 6;
             lut_g[i] = drmmode_crtc->lut_g[i] << 6;
             lut_b[i] = drmmode_crtc->lut_b[i] << 6;
         }
 
-        switch(pScrn->depth) {
+        switch (pScrn->depth) {
         case 15:
             for (i = 0; i < numColors; i++) {
                 index = indices[i];
@@ -1356,56 +1399,55 @@ static void drmmode_load_palette(ScrnInfoPtr pScrn, int numColors,
                     lut_b[index * 8 + j] = colors[index].blue << 6;
                 }
             }
-         break;
-         case 16:
-             for (i = 0; i < numColors; i++) {
-                 index = indices[i];
-
-                  if (i <= 31) {
-                      for (j = 0; j < 8; j++) {
-                          lut_r[index * 8 + j] = colors[index].red << 6;
-                          lut_b[index * 8 + j] = colors[index].blue << 6;
-                      }
-                  }
-
-                  for (j = 0; j < 4; j++) {
-                      lut_g[index * 4 + j] = colors[index].green << 6;
-                  }
-              }
-	  break;
-          default:
-              for (i = 0; i < numColors; i++) {
-                  index = indices[i];
-                  lut_r[index] = colors[index].red << 6;
-                  lut_g[index] = colors[index].green << 6;
-                  lut_b[index] = colors[index].blue << 6;
-              }
-              break;
-          }
-
-    /* Make the change through RandR */
+            break;
+        case 16:
+            for (i = 0; i < numColors; i++) {
+                index = indices[i];
+
+                if (i <= 31) {
+                    for (j = 0; j < 8; j++) {
+                        lut_r[index * 8 + j] = colors[index].red << 6;
+                        lut_b[index * 8 + j] = colors[index].blue << 6;
+                    }
+                }
+
+                for (j = 0; j < 4; j++) {
+                    lut_g[index * 4 + j] = colors[index].green << 6;
+                }
+            }
+            break;
+        default:
+            for (i = 0; i < numColors; i++) {
+                index = indices[i];
+                lut_r[index] = colors[index].red << 6;
+                lut_g[index] = colors[index].green << 6;
+                lut_b[index] = colors[index].blue << 6;
+            }
+            break;
+        }
+
+        /* Make the change through RandR */
         if (crtc->randr_crtc)
             RRCrtcGammaSet(crtc->randr_crtc, lut_r, lut_g, lut_b);
         else
             crtc->funcs->gamma_set(crtc, lut_r, lut_g, lut_b, 256);
-     }
+    }
 }
 
-Bool drmmode_setup_colormap(ScreenPtr pScreen, ScrnInfoPtr pScrn)
+Bool
+drmmode_setup_colormap(ScreenPtr pScreen, ScrnInfoPtr pScrn)
 {
-    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 0,
-                  "Initializing kms color map\n");
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 0, "Initializing kms color map\n");
     if (!miCreateDefColormap(pScreen))
         return FALSE;
     /* all radeons support 10 bit CLUTs */
     if (!xf86HandleColormaps(pScreen, 256, 10,
-                             drmmode_load_palette, NULL,
-                             CMAP_PALETTED_TRUECOLOR
-#if 0 /* This option messes up text mode! (eich@suse.de) */
+                             drmmode_load_palette, NULL, CMAP_PALETTED_TRUECOLOR
+#if 0                           /* This option messes up text mode! (eich@suse.de) */
                              | CMAP_LOAD_EVEN_IF_OFFSCREEN
 #endif
                              | CMAP_RELOAD_ON_MODE_SWITCH))
-         return FALSE;
+        return FALSE;
     return TRUE;
 }
 
@@ -1413,204 +1455,220 @@ Bool drmmode_setup_colormap(ScreenPtr pScreen, ScrnInfoPtr pScrn)
 static void
 drmmode_handle_uevents(int fd, void *closure)
 {
-	drmmode_ptr drmmode = closure;
-	ScrnInfoPtr scrn = drmmode->scrn;
-	struct udev_device *dev;
-	dev = udev_monitor_receive_device(drmmode->uevent_monitor);
-	if (!dev)
-		return;
-
-	RRGetInfo(xf86ScrnToScreen(scrn), TRUE);
-	udev_device_unref(dev);
+    drmmode_ptr drmmode = closure;
+    ScrnInfoPtr scrn = drmmode->scrn;
+    struct udev_device *dev;
+
+    dev = udev_monitor_receive_device(drmmode->uevent_monitor);
+    if (!dev)
+        return;
+
+    RRGetInfo(xf86ScrnToScreen(scrn), TRUE);
+    udev_device_unref(dev);
 }
 #endif
 
-void drmmode_uevent_init(ScrnInfoPtr scrn, drmmode_ptr drmmode)
+void
+drmmode_uevent_init(ScrnInfoPtr scrn, drmmode_ptr drmmode)
 {
 #ifdef HAVE_UDEV
-	struct udev *u;
-	struct udev_monitor *mon;
-
-	u = udev_new();
-	if (!u)
-		return;
-	mon = udev_monitor_new_from_netlink(u, "udev");
-	if (!mon) {
-		udev_unref(u);
-		return;
-	}
-
-	if (udev_monitor_filter_add_match_subsystem_devtype(mon,
-							    "drm",
-							    "drm_minor") < 0 ||
-	    udev_monitor_enable_receiving(mon) < 0) {
-		udev_monitor_unref(mon);
-		udev_unref(u);
-		return;
-	}
-
-	drmmode->uevent_handler =
-		xf86AddGeneralHandler(udev_monitor_get_fd(mon),
-				      drmmode_handle_uevents,
-				      drmmode);
-
-	drmmode->uevent_monitor = mon;
+    struct udev *u;
+    struct udev_monitor *mon;
+
+    u = udev_new();
+    if (!u)
+        return;
+    mon = udev_monitor_new_from_netlink(u, "udev");
+    if (!mon) {
+        udev_unref(u);
+        return;
+    }
+
+    if (udev_monitor_filter_add_match_subsystem_devtype(mon,
+                                                        "drm",
+                                                        "drm_minor") < 0 ||
+        udev_monitor_enable_receiving(mon) < 0) {
+        udev_monitor_unref(mon);
+        udev_unref(u);
+        return;
+    }
+
+    drmmode->uevent_handler =
+        xf86AddGeneralHandler(udev_monitor_get_fd(mon),
+                              drmmode_handle_uevents, drmmode);
+
+    drmmode->uevent_monitor = mon;
 #endif
 }
 
-void drmmode_uevent_fini(ScrnInfoPtr scrn, drmmode_ptr drmmode)
+void
+drmmode_uevent_fini(ScrnInfoPtr scrn, drmmode_ptr drmmode)
 {
 #ifdef HAVE_UDEV
-	if (drmmode->uevent_handler) {
-		struct udev *u = udev_monitor_get_udev(drmmode->uevent_monitor);
-		xf86RemoveGeneralHandler(drmmode->uevent_handler);
+    if (drmmode->uevent_handler) {
+        struct udev *u = udev_monitor_get_udev(drmmode->uevent_monitor);
+
+        xf86RemoveGeneralHandler(drmmode->uevent_handler);
 
-		udev_monitor_unref(drmmode->uevent_monitor);
-		udev_unref(u);
-	}
+        udev_monitor_unref(drmmode->uevent_monitor);
+        udev_unref(u);
+    }
 #endif
 }
 
 /* create front and cursor BOs */
-Bool drmmode_create_initial_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
+Bool
+drmmode_create_initial_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
 {
-	modesettingPtr ms = modesettingPTR(pScrn);
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-	int width;
-	int height;
-	int bpp = pScrn->bitsPerPixel;
-	int i;
-	int cpp = (bpp + 7) / 8;
-
-	width = pScrn->virtualX;
-	height = pScrn->virtualY;
-
-	drmmode->front_bo = dumb_bo_create(drmmode->fd, width, height, bpp);
-	if (!drmmode->front_bo)
-		return FALSE;
-	pScrn->displayWidth = drmmode->front_bo->pitch / cpp;
-
-	width = ms->cursor_width;
-	height = ms->cursor_height;
-	bpp = 32;
-	for (i = 0; i < xf86_config->num_crtc; i++) {
-		xf86CrtcPtr crtc = xf86_config->crtc[i];
-		drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-		drmmode_crtc->cursor_bo = dumb_bo_create(drmmode->fd, width, height, bpp);
-	}
-	return TRUE;
+    modesettingPtr ms = modesettingPTR(pScrn);
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int width;
+    int height;
+    int bpp = pScrn->bitsPerPixel;
+    int i;
+    int cpp = (bpp + 7) / 8;
+
+    width = pScrn->virtualX;
+    height = pScrn->virtualY;
+
+    drmmode->front_bo = dumb_bo_create(drmmode->fd, width, height, bpp);
+    if (!drmmode->front_bo)
+        return FALSE;
+    pScrn->displayWidth = drmmode->front_bo->pitch / cpp;
+
+    width = ms->cursor_width;
+    height = ms->cursor_height;
+    bpp = 32;
+    for (i = 0; i < xf86_config->num_crtc; i++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[i];
+        drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+
+        drmmode_crtc->cursor_bo =
+            dumb_bo_create(drmmode->fd, width, height, bpp);
+    }
+    return TRUE;
 }
 
-void *drmmode_map_front_bo(drmmode_ptr drmmode)
+void *
+drmmode_map_front_bo(drmmode_ptr drmmode)
 {
-	int ret;
+    int ret;
 
-	if (drmmode->front_bo->ptr)
-		return drmmode->front_bo->ptr;
+    if (drmmode->front_bo->ptr)
+        return drmmode->front_bo->ptr;
 
-	ret = dumb_bo_map(drmmode->fd, drmmode->front_bo);
-	if (ret)
-		return NULL;
+    ret = dumb_bo_map(drmmode->fd, drmmode->front_bo);
+    if (ret)
+        return NULL;
+
+    return drmmode->front_bo->ptr;
 
-	return drmmode->front_bo->ptr;
-	
 }
 
-void *drmmode_map_slave_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv)
+void *
+drmmode_map_slave_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv)
 {
-        int ret;
+    int ret;
 
-        if (ppriv->backing_bo->ptr)
-                return ppriv->backing_bo->ptr;
+    if (ppriv->backing_bo->ptr)
+        return ppriv->backing_bo->ptr;
 
-        ret = dumb_bo_map(drmmode->fd, ppriv->backing_bo);
-        if (ret)
-                return NULL;
+    ret = dumb_bo_map(drmmode->fd, ppriv->backing_bo);
+    if (ret)
+        return NULL;
 
-        return ppriv->backing_bo->ptr;  
+    return ppriv->backing_bo->ptr;
 }
 
-Bool drmmode_map_cursor_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
+Bool
+drmmode_map_cursor_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
 {
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-	int i, ret;
-	for (i = 0; i < xf86_config->num_crtc; i++) {
-		xf86CrtcPtr crtc = xf86_config->crtc[i];
-		drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-		ret = dumb_bo_map(drmmode->fd, drmmode_crtc->cursor_bo);
-		if (ret)
-			return FALSE;
-	}
-	return TRUE;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int i, ret;
+
+    for (i = 0; i < xf86_config->num_crtc; i++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[i];
+        drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+
+        ret = dumb_bo_map(drmmode->fd, drmmode_crtc->cursor_bo);
+        if (ret)
+            return FALSE;
+    }
+    return TRUE;
 }
 
-void drmmode_free_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
+void
+drmmode_free_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode)
 {
-	xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
-	int i;
-
-	if (drmmode->fb_id) {
-		drmModeRmFB(drmmode->fd, drmmode->fb_id);
-		drmmode->fb_id = 0;
-	}
-
-	dumb_bo_destroy(drmmode->fd, drmmode->front_bo);
-	drmmode->front_bo = NULL;
-
-	for (i = 0; i < xf86_config->num_crtc; i++) {
-		xf86CrtcPtr crtc = xf86_config->crtc[i];
-		drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
-		dumb_bo_destroy(drmmode->fd, drmmode_crtc->cursor_bo);
-	}
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int i;
+
+    if (drmmode->fb_id) {
+        drmModeRmFB(drmmode->fd, drmmode->fb_id);
+        drmmode->fb_id = 0;
+    }
+
+    dumb_bo_destroy(drmmode->fd, drmmode->front_bo);
+    drmmode->front_bo = NULL;
+
+    for (i = 0; i < xf86_config->num_crtc; i++) {
+        xf86CrtcPtr crtc = xf86_config->crtc[i];
+        drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
+
+        dumb_bo_destroy(drmmode->fd, drmmode_crtc->cursor_bo);
+    }
 }
 
 /* ugly workaround to see if we can create 32bpp */
-void drmmode_get_default_bpp(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int *depth, int *bpp)
+void
+drmmode_get_default_bpp(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int *depth,
+                        int *bpp)
 {
-	drmModeResPtr mode_res;
-	uint64_t value;
-	struct dumb_bo *bo;
-	uint32_t fb_id;
-	int ret;
-
-	/* 16 is fine */
-	ret = drmGetCap(drmmode->fd, DRM_CAP_DUMB_PREFERRED_DEPTH, &value);
-	if (!ret && (value == 16 || value == 8)) {
-		*depth = value;
-		*bpp = value;
-		return;
-	}
-
-	*depth = 24;
-	mode_res = drmModeGetResources(drmmode->fd);
-	if (!mode_res)
-		return;
-
-	if (mode_res->min_width == 0)
-		mode_res->min_width = 1;
-	if (mode_res->min_height == 0)
-		mode_res->min_height = 1;
-	/*create a bo */
-	bo = dumb_bo_create(drmmode->fd, mode_res->min_width, mode_res->min_height, 32);
-	if (!bo) {
-		*bpp = 24;
-		goto out;
-	}
-
-	ret = drmModeAddFB(drmmode->fd, mode_res->min_width, mode_res->min_height,
-			    24, 32, bo->pitch, bo->handle, &fb_id);
-
-	if (ret) {
-		*bpp = 24;
-		dumb_bo_destroy(drmmode->fd, bo);
-		goto out;
-	}
-
-	drmModeRmFB(drmmode->fd, fb_id);
-	*bpp = 32;
-
-	dumb_bo_destroy(drmmode->fd, bo);
-out:	
-	drmModeFreeResources(mode_res);
-	return;
+    drmModeResPtr mode_res;
+    uint64_t value;
+    struct dumb_bo *bo;
+    uint32_t fb_id;
+    int ret;
+
+    /* 16 is fine */
+    ret = drmGetCap(drmmode->fd, DRM_CAP_DUMB_PREFERRED_DEPTH, &value);
+    if (!ret && (value == 16 || value == 8)) {
+        *depth = value;
+        *bpp = value;
+        return;
+    }
+
+    *depth = 24;
+    mode_res = drmModeGetResources(drmmode->fd);
+    if (!mode_res)
+        return;
+
+    if (mode_res->min_width == 0)
+        mode_res->min_width = 1;
+    if (mode_res->min_height == 0)
+        mode_res->min_height = 1;
+    /*create a bo */
+    bo = dumb_bo_create(drmmode->fd, mode_res->min_width, mode_res->min_height,
+                        32);
+    if (!bo) {
+        *bpp = 24;
+        goto out;
+    }
+
+    ret = drmModeAddFB(drmmode->fd, mode_res->min_width, mode_res->min_height,
+                       24, 32, bo->pitch, bo->handle, &fb_id);
+
+    if (ret) {
+        *bpp = 24;
+        dumb_bo_destroy(drmmode->fd, bo);
+        goto out;
+    }
+
+    drmModeRmFB(drmmode->fd, fb_id);
+    *bpp = 32;
+
+    dumb_bo_destroy(drmmode->fd, bo);
+ out:
+    drmModeFreeResources(mode_res);
+    return;
 }
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.h b/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.h
index 7bfe885f5..438743b01 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.h
+++ b/xorg-server/hw/xfree86/drivers/modesetting/drmmode_display.h
@@ -74,11 +74,10 @@ typedef struct {
 typedef struct {
     drmModePropertyPtr mode_prop;
     uint64_t value;
-    int num_atoms; /* if range prop, num_atoms == 1; if enum prop, num_atoms == num_enums + 1 */
+    int num_atoms;              /* if range prop, num_atoms == 1; if enum prop, num_atoms == num_enums + 1 */
     Atom *atoms;
 } drmmode_prop_rec, *drmmode_prop_ptr;
 
-
 typedef struct {
     drmmode_ptr drmmode;
     int output_id;
@@ -97,16 +96,16 @@ typedef struct _msPixmapPriv {
     struct dumb_bo *backing_bo; /* if this pixmap is backed by a dumb bo */
 } msPixmapPrivRec, *msPixmapPrivPtr;
 
-
 extern DevPrivateKeyRec msPixmapPrivateKeyRec;
+
 #define msPixmapPrivateKey (&msPixmapPrivateKeyRec)
 
 #define msGetPixmapPriv(drmmode, p) ((msPixmapPrivPtr)dixGetPrivateAddr(&(p)->devPrivates, &(drmmode)->pixmapPrivateKeyRec))
 
 void *drmmode_map_slave_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv);
 Bool drmmode_SetSlaveBO(PixmapPtr ppix,
-			drmmode_ptr drmmode,
-			int fd_handle, int pitch, int size);
+                        drmmode_ptr drmmode,
+                        int fd_handle, int pitch, int size);
 
 extern Bool drmmode_pre_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int cpp);
 void drmmode_adjust_frame(ScrnInfoPtr pScrn, drmmode_ptr drmmode, int x, int y);
@@ -120,8 +119,8 @@ Bool drmmode_create_initial_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode);
 void *drmmode_map_front_bo(drmmode_ptr drmmode);
 Bool drmmode_map_cursor_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode);
 void drmmode_free_bos(ScrnInfoPtr pScrn, drmmode_ptr drmmode);
-void drmmode_get_default_bpp(ScrnInfoPtr pScrn, drmmode_ptr drmmmode, int *depth, int *bpp);
-
+void drmmode_get_default_bpp(ScrnInfoPtr pScrn, drmmode_ptr drmmmode,
+                             int *depth, int *bpp);
 
 #ifndef DRM_CAP_DUMB_PREFERRED_DEPTH
 #define DRM_CAP_DUMB_PREFERRED_DEPTH 3
@@ -132,5 +131,4 @@ void drmmode_get_default_bpp(ScrnInfoPtr pScrn, drmmode_ptr drmmmode, int *depth
 
 #define MS_ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
-
 #endif
diff --git a/xorg-server/hw/xfree86/drivers/modesetting/modesetting.man b/xorg-server/hw/xfree86/drivers/modesetting/modesetting.man
index 34baa9c53..9cb27d728 100644
--- a/xorg-server/hw/xfree86/drivers/modesetting/modesetting.man
+++ b/xorg-server/hw/xfree86/drivers/modesetting/modesetting.man
@@ -47,6 +47,9 @@ The framebuffer device to use. Default: /dev/dri/card0.
 .BI "Option \*qShadowFB\*q \*q" boolean \*q
 Enable or disable use of the shadow framebuffer layer.  Default: on.
 .TP
+.BI "Option \*qAccelMethod\*q \*q" string \*q
+One of \*qglamor\*q or \*qnone\*q.  Default: glamor
+.TP
 .SH "SEE ALSO"
 __xservername__(__appmansuffix__), __xconfigfile__(__filemansuffix__), Xserver(__appmansuffix__),
 X(__miscmansuffix__)
diff --git a/xorg-server/hw/xfree86/loader/loader.c b/xorg-server/hw/xfree86/loader/loader.c
index cc41dcb4c..31329846a 100644
--- a/xorg-server/hw/xfree86/loader/loader.c
+++ b/xorg-server/hw/xfree86/loader/loader.c
@@ -71,24 +71,6 @@
 #include <dlfcn.h>
 #include <X11/Xos.h>
 
-#if defined(DL_LAZY)
-#define DLOPEN_LAZY DL_LAZY
-#elif defined(RTLD_LAZY)
-#define DLOPEN_LAZY RTLD_LAZY
-#elif defined(__FreeBSD__)
-#define DLOPEN_LAZY 1
-#else
-#define DLOPEN_LAZY 0
-#endif
-
-#if defined(LD_GLOBAL)
-#define DLOPEN_GLOBAL LD_GLOBAL
-#elif defined(RTLD_GLOBAL)
-#define DLOPEN_GLOBAL RTLD_GLOBAL
-#else
-#define DLOPEN_GLOBAL 0
-#endif
-
 #else
 #error i have no dynamic linker and i must scream
 #endif
@@ -128,7 +110,7 @@ LoaderOpen(const char *module, int *errmaj, int *errmin)
 
     xf86Msg(X_INFO, "Loading %s\n", module);
 
-    if (!(ret = dlopen(module, DLOPEN_LAZY | DLOPEN_GLOBAL))) {
+    if (!(ret = dlopen(module, RTLD_LAZY | RTLD_GLOBAL))) {
         xf86Msg(X_ERROR, "Failed to load %s: %s\n", module, dlerror());
         if (errmaj)
             *errmaj = LDR_NOLOAD;
@@ -151,7 +133,7 @@ LoaderSymbol(const char *name)
         return p;
 
     if (!global_scope)
-        global_scope = dlopen(NULL, DLOPEN_LAZY | DLOPEN_GLOBAL);
+        global_scope = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
 
     if (global_scope)
         return dlsym(global_scope, name);
diff --git a/xorg-server/hw/xfree86/loader/loadmod.c b/xorg-server/hw/xfree86/loader/loadmod.c
index 21ccb1bf9..7021bdd4c 100644
--- a/xorg-server/hw/xfree86/loader/loadmod.c
+++ b/xorg-server/hw/xfree86/loader/loadmod.c
@@ -77,12 +77,8 @@ typedef struct _pattern {
 static char *FindModule(const char *, const char *, const char **, PatternPtr);
 static Bool CheckVersion(const char *, XF86ModuleVersionInfo *,
                          const XF86ModReqInfo *);
-static void UnloadModuleOrDriver(ModuleDescPtr mod);
 static char *LoaderGetCanonicalName(const char *, PatternPtr);
 static void RemoveChild(ModuleDescPtr);
-static ModuleDescPtr doLoadModule(const char *, const char *, const char **,
-                                  const char **, void *,
-                                  const XF86ModReqInfo *, int *, int *);
 
 const ModuleVersions LoaderVersionInfo = {
     XORG_VERSION_CURRENT,
@@ -754,8 +750,8 @@ LoadSubModule(void *_parent, const char *module,
         return NULL;
     }
 
-    submod = doLoadModule(module, NULL, subdirlist, patternlist, options,
-                          modreq, errmaj, errmin);
+    submod = LoadModule(module, NULL, subdirlist, patternlist, options,
+                        modreq, errmaj, errmin);
     if (submod && submod != (ModuleDescPtr) 1) {
         parent->child = AddSibling(parent->child, submod);
         submod->parent = parent;
@@ -818,10 +814,47 @@ static const char *compiled_in_modules[] = {
     NULL
 };
 
-static ModuleDescPtr
-doLoadModule(const char *module, const char *path, const char **subdirlist,
-             const char **patternlist, void *options,
-             const XF86ModReqInfo * modreq, int *errmaj, int *errmin)
+/*
+ * LoadModule: load a module
+ *
+ * module       The module name.  Normally this is not a filename but the
+ *              module's "canonical name.  A full pathname is, however,
+ *              also accepted.
+ * path         A comma separated list of module directories.
+ * subdirlist   A NULL terminated list of subdirectories to search.  When
+ *              NULL, the default "stdSubdirs" list is used.  The default
+ *              list is also substituted for entries with value DEFAULT_LIST.
+ * patternlist  A NULL terminated list of regular expressions used to find
+ *              module filenames.  Each regex should contain exactly one
+ *              subexpression that corresponds to the canonical module name.
+ *              When NULL, the default "stdPatterns" list is used.  The
+ *              default list is also substituted for entries with value
+ *              DEFAULT_LIST.
+ * options      A NULL terminated list of Options that are passed to the
+ *              module's SetupProc function.
+ * modreq       An optional XF86ModReqInfo* containing
+ *              version/ABI/vendor-ABI requirements to check for when
+ *              loading the module.  The following fields of the
+ *              XF86ModReqInfo struct are checked:
+ *                majorversion - must match the module's majorversion exactly
+ *                minorversion - the module's minorversion must be >= this
+ *                patchlevel   - the module's minorversion.patchlevel must be
+ *                               >= this.  Patchlevel is ignored when
+ *                               minorversion is not set.
+ *                abiclass     - (string) must match the module's abiclass
+ *                abiversion   - must be consistent with the module's
+ *                               abiversion (major equal, minor no older)
+ *                moduleclass  - string must match the module's moduleclass
+ *                               string
+ *              "don't care" values are ~0 for numbers, and NULL for strings
+ * errmaj       Major error return.
+ * errmin       Minor error return.
+ *
+ */
+ModuleDescPtr
+LoadModule(const char *module, const char *path, const char **subdirlist,
+           const char **patternlist, void *options,
+           const XF86ModReqInfo * modreq, int *errmaj, int *errmin)
 {
     XF86ModuleData *initdata = NULL;
     char **pathlist = NULL;
@@ -1009,61 +1042,11 @@ doLoadModule(const char *module, const char *path, const char **subdirlist,
     return ret;
 }
 
-/*
- * LoadModule: load a module
- *
- * module       The module name.  Normally this is not a filename but the
- *              module's "canonical name.  A full pathname is, however,
- *              also accepted.
- * path         A comma separated list of module directories.
- * subdirlist   A NULL terminated list of subdirectories to search.  When
- *              NULL, the default "stdSubdirs" list is used.  The default
- *              list is also substituted for entries with value DEFAULT_LIST.
- * patternlist  A NULL terminated list of regular expressions used to find
- *              module filenames.  Each regex should contain exactly one
- *              subexpression that corresponds to the canonical module name.
- *              When NULL, the default "stdPatterns" list is used.  The
- *              default list is also substituted for entries with value
- *              DEFAULT_LIST.
- * options      A NULL terminated list of Options that are passed to the
- *              module's SetupProc function.
- * modreq       An optional XF86ModReqInfo* containing
- *              version/ABI/vendor-ABI requirements to check for when
- *              loading the module.  The following fields of the
- *              XF86ModReqInfo struct are checked:
- *                majorversion - must match the module's majorversion exactly
- *                minorversion - the module's minorversion must be >= this
- *                patchlevel   - the module's minorversion.patchlevel must be
- *                               >= this.  Patchlevel is ignored when
- *                               minorversion is not set.
- *                abiclass     - (string) must match the module's abiclass
- *                abiversion   - must be consistent with the module's
- *                               abiversion (major equal, minor no older)
- *                moduleclass  - string must match the module's moduleclass
- *                               string
- *              "don't care" values are ~0 for numbers, and NULL for strings
- * errmaj       Major error return.
- * errmin       Minor error return.
- *
- */
-ModuleDescPtr
-LoadModule(const char *module, const char *path, const char **subdirlist,
-           const char **patternlist, void *options,
-           const XF86ModReqInfo * modreq, int *errmaj, int *errmin)
-{
-    return doLoadModule(module, path, subdirlist, patternlist, options,
-                        modreq, errmaj, errmin);
-}
-
 void
-UnloadModule(void *mod)
+UnloadModule(void *_mod)
 {
-    UnloadModuleOrDriver((ModuleDescPtr) mod);
-}
+    ModuleDescPtr mod = _mod;
 
-static void
-UnloadModuleOrDriver(ModuleDescPtr mod)
-{
     if (mod == (ModuleDescPtr) 1)
         return;
 
@@ -1083,9 +1066,9 @@ UnloadModuleOrDriver(ModuleDescPtr mod)
     }
 
     if (mod->child)
-        UnloadModuleOrDriver(mod->child);
+        UnloadModule(mod->child);
     if (mod->sib)
-        UnloadModuleOrDriver(mod->sib);
+        UnloadModule(mod->sib);
     free(mod->path);
     free(mod->name);
     free(mod);
@@ -1100,7 +1083,7 @@ UnloadSubModule(void *_mod)
     if (mod == (ModuleDescPtr) 1)
         return;
     RemoveChild(mod);
-    UnloadModuleOrDriver(mod);
+    UnloadModule(mod);
 }
 
 static void
diff --git a/xorg-server/hw/xfree86/man/xorg.conf.man b/xorg-server/hw/xfree86/man/xorg.conf.man
index 378f26b59..d26c3cc4d 100644
--- a/xorg-server/hw/xfree86/man/xorg.conf.man
+++ b/xorg-server/hw/xfree86/man/xorg.conf.man
@@ -1449,12 +1449,6 @@ This optional entry specifies the chip revision number.
 This can be used to override the auto-detection, but that should only be done
 when the driver-specific documentation recommends it.
 .TP 7
-.BI "TextClockFreq  " "freq"
-This optional entry specifies the pixel clock frequency that is used
-for the regular text mode.
-The frequency is specified in MHz.
-This is rarely used.
-.TP 7
 .BI "MatchSeat  " "seat\-id"
 Only apply this
 .B Device
diff --git a/xorg-server/hw/xfree86/modes/Makefile.am b/xorg-server/hw/xfree86/modes/Makefile.am
index 220643f7b..6eb162a89 100644
--- a/xorg-server/hw/xfree86/modes/Makefile.am
+++ b/xorg-server/hw/xfree86/modes/Makefile.am
@@ -10,7 +10,6 @@ libxf86modes_la_SOURCES = \
 	xf86Cursors.c \
 	xf86cvt.c \
 	xf86gtf.c \
-	xf86DisplayIDModes.c \
 	xf86EdidModes.c \
 	xf86Modes.c \
 	xf86Modes.h \
diff --git a/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c b/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c
deleted file mode 100644
index c2e771894..000000000
--- a/xorg-server/hw/xfree86/modes/xf86DisplayIDModes.c
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
- * 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 "xf86Modes.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/parser/Device.c b/xorg-server/hw/xfree86/parser/Device.c
index d3ac29351..28c274d72 100644
--- a/xorg-server/hw/xfree86/parser/Device.c
+++ b/xorg-server/hw/xfree86/parser/Device.c
@@ -83,7 +83,6 @@ xf86ConfigSymTabRec DeviceTab[] = {
     {CARD, "card"},
     {DRIVER, "driver"},
     {BUSID, "busid"},
-    {TEXTCLOCKFRQ, "textclockfreq"},
     {IRQ, "irq"},
     {SCREEN, "screen"},
     {-1, ""},
@@ -212,11 +211,6 @@ xf86parseDeviceSection(void)
             ptr->dev_clocks = i;
             xf86unGetToken(token);
             break;
-        case TEXTCLOCKFRQ:
-            if ((token = xf86getSubToken(&(ptr->dev_comment))) != NUMBER)
-                Error(NUMBER_MSG, "TextClockFreq");
-            ptr->dev_textclockfreq = (int) (xf86_lex_val.realnum * 1000.0 + 0.5);
-            break;
         case MATCHSEAT:
             if (xf86getSubToken(&(ptr->dev_comment)) != STRING)
                 Error(QUOTE_MSG, "MatchSeat");
@@ -312,10 +306,6 @@ xf86printDeviceSection(FILE * cf, XF86ConfDevicePtr ptr)
                 fprintf(cf, "%.1f ", (double) ptr->dev_clock[i] / 1000.0);
             fprintf(cf, "\n");
         }
-        if (ptr->dev_textclockfreq) {
-            fprintf(cf, "\tTextClockFreq %.1f\n",
-                    (double) ptr->dev_textclockfreq / 1000.0);
-        }
         if (ptr->dev_busid)
             fprintf(cf, "\tBusID       \"%s\"\n", ptr->dev_busid);
         if (ptr->dev_screen > 0)
diff --git a/xorg-server/hw/xfree86/parser/xf86Parser.h b/xorg-server/hw/xfree86/parser/xf86Parser.h
index 3fa5b716d..73187f33a 100644
--- a/xorg-server/hw/xfree86/parser/xf86Parser.h
+++ b/xorg-server/hw/xfree86/parser/xf86Parser.h
@@ -211,7 +211,6 @@ typedef struct {
     const char *dev_ramdac;
     int dev_dacSpeeds[CONF_MAXDACSPEEDS];
     int dev_videoram;
-    int dev_textclockfreq;
     unsigned long dev_bios_base;
     unsigned long dev_mem_base;
     unsigned long dev_io_base;
diff --git a/xorg-server/hw/xfree86/parser/xf86tokens.h b/xorg-server/hw/xfree86/parser/xf86tokens.h
index 5c01ce701..8e15f122a 100644
--- a/xorg-server/hw/xfree86/parser/xf86tokens.h
+++ b/xorg-server/hw/xfree86/parser/xf86tokens.h
@@ -187,7 +187,6 @@ typedef enum {
     CHIPREV,
     CARD,
     BUSID,
-    TEXTCLOCKFRQ,
     IRQ,
 
     /* Keyboard tokens */
diff --git a/xorg-server/hw/xfree86/x86emu/x86emu/x86emui.h b/xorg-server/hw/xfree86/x86emu/x86emu/x86emui.h
index 5e20d9705..01bd92a6f 100644
--- a/xorg-server/hw/xfree86/x86emu/x86emu/x86emui.h
+++ b/xorg-server/hw/xfree86/x86emu/x86emu/x86emui.h
@@ -46,7 +46,7 @@
  * dramatically in this case).
  */
 
-#if	defined(__cplusplus) && !defined(_NO_INLINE)
+#if defined(__cplusplus)
 #define	_INLINE	inline
 #else
 #define	_INLINE static
diff --git a/xorg-server/hw/xnest/Window.c b/xorg-server/hw/xnest/Window.c
index fc87e823e..8d9c67205 100644
--- a/xorg-server/hw/xnest/Window.c
+++ b/xorg-server/hw/xnest/Window.c
@@ -386,7 +386,7 @@ xnestWindowExposurePredicate(Display * dpy, XEvent * event, XPointer ptr)
 }
 
 void
-xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
+xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn)
 {
     XEvent event;
     Window window;
@@ -410,7 +410,7 @@ xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
             XPutBackEvent(xnestDisplay, &event);
     }
 
-    miWindowExposures(pWin, pRgn, other_exposed);
+    miWindowExposures(pWin, pRgn);
 }
 
 void
diff --git a/xorg-server/hw/xnest/XNWindow.h b/xorg-server/hw/xnest/XNWindow.h
index 02b0f3f36..6320ede5e 100644
--- a/xorg-server/hw/xnest/XNWindow.h
+++ b/xorg-server/hw/xnest/XNWindow.h
@@ -66,8 +66,7 @@ Bool xnestRealizeWindow(WindowPtr pWin);
 Bool xnestUnrealizeWindow(WindowPtr pWin);
 void xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion);
 void xnestClipNotify(WindowPtr pWin, int dx, int dy);
-void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn,
-                          RegionPtr other_exposed);
+void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn);
 void xnestSetShape(WindowPtr pWin, int kind);
 void xnestShapeWindow(WindowPtr pWin);
 
diff --git a/xorg-server/hw/xquartz/xpr/dri.c b/xorg-server/hw/xquartz/xpr/dri.c
index 0f1904738..565d94f5f 100644
--- a/xorg-server/hw/xquartz/xpr/dri.c
+++ b/xorg-server/hw/xquartz/xpr/dri.c
@@ -138,9 +138,6 @@ DRIFinishScreenInit(ScreenPtr pScreen)
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
     /* Wrap DRI support */
-    pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;
-    pScreen->WindowExposures = DRIWindowExposures;
-
     pDRIPriv->wrap.CopyWindow = pScreen->CopyWindow;
     pScreen->CopyWindow = DRICopyWindow;
 
@@ -577,24 +574,6 @@ DRIDrawablePrivDelete(void *pResource, XID id)
 }
 
 void
-DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
-    DRIDrawablePrivPtr pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
-
-    if (pDRIDrawablePriv) {
-        /* FIXME: something? */
-    }
-
-    pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures;
-
-    (*pScreen->WindowExposures)(pWin, prgn, bsreg);
-
-    pScreen->WindowExposures = DRIWindowExposures;
-}
-
-void
 DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 {
     ScreenPtr pScreen = pWin->drawable.pScreen;
diff --git a/xorg-server/hw/xquartz/xpr/dri.h b/xorg-server/hw/xquartz/xpr/dri.h
index 4476b06af..a4400a220 100644
--- a/xorg-server/hw/xquartz/xpr/dri.h
+++ b/xorg-server/hw/xquartz/xpr/dri.h
@@ -51,7 +51,6 @@ typedef void (*ClipNotifyPtr)(WindowPtr, int, int);
  * overridden by the driver in its [driver]DRIScreenInit function.
  */
 typedef struct {
-    WindowExposuresProcPtr WindowExposures;
     CopyWindowProcPtr CopyWindow;
     ClipNotifyProcPtr ClipNotify;
 } DRIWrappedFuncsRec, *DRIWrappedFuncsPtr;
@@ -109,9 +108,6 @@ extern void
 DRIClipNotify(WindowPtr pWin, int dx, int dy);
 
 extern void
-DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg);
-
-extern void
 DRISurfaceNotify(xp_surface_id id, int kind);
 
 extern void
diff --git a/xorg-server/hw/xwin/winclipboard/thread.c b/xorg-server/hw/xwin/winclipboard/thread.c
index 50cf997fb..5dee3040e 100755
--- a/xorg-server/hw/xwin/winclipboard/thread.c
+++ b/xorg-server/hw/xwin/winclipboard/thread.c
@@ -111,6 +111,7 @@ winClipboardProc(Bool fUseUnicode, char *szDisplay)
     int iReturn;
     HWND hwnd = NULL;
     int iConnectionNumber = 0;
+    Bool bShutDown = TRUE;
 
 #ifdef HAS_DEVWINDOWS
     int fdMessageQueue = 0;
@@ -161,6 +162,7 @@ winClipboardProc(Bool fUseUnicode, char *szDisplay)
     pDisplay = XOpenDisplay(szDisplay);
     if (pDisplay == NULL) {
         ErrorF("winClipboardProc - Failed opening the display, giving up\n");
+        bShutDown = FALSE;
         goto thread_errorexit;
     }
 
@@ -397,7 +399,7 @@ commonexit:
 
     pthread_cleanup_pop(0);
 
-    return FALSE;
+    return bShutDown;
 }
 
 /*
diff --git a/xorg-server/hw/xwin/winconfig.h b/xorg-server/hw/xwin/winconfig.h
index 798c779a6..f079368c7 100644
--- a/xorg-server/hw/xwin/winconfig.h
+++ b/xorg-server/hw/xwin/winconfig.h
@@ -57,7 +57,6 @@ typedef struct {
     Bool active;
     Bool inUse;
     int videoRam;
-    int textClockFreq;
     void *options;
     int screen;                 /* For multi-CRTC cards */
 } GDevRec, *GDevPtr;
diff --git a/xorg-server/include/dix-config.h.in b/xorg-server/include/dix-config.h.in
index f170c1c2f..1aa77a5eb 100644
--- a/xorg-server/include/dix-config.h.in
+++ b/xorg-server/include/dix-config.h.in
@@ -72,6 +72,10 @@
 /* Define to 1 if you have the <dbm.h> header file. */
 #undef HAVE_DBM_H
 
+/* Define to 1 if you have the declaration of `program_invocation_short_name', and
+   to 0 if you don't. */
+#undef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
+
 /* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
    */
 #undef HAVE_DIRENT_H
@@ -100,6 +104,9 @@
 /* Define to 1 if you have the `getpeerucred' function. */
 #undef HAVE_GETPEERUCRED
 
+/* Define to 1 if you have the `getprogname' function. */
+#undef HAVE_GETPROGNAME
+
 /* Define to 1 if you have the `getzoneid' function. */
 #undef HAVE_GETZONEID
 
diff --git a/xorg-server/include/dix.h b/xorg-server/include/dix.h
index 61ecc8df2..116da2e2c 100755
--- a/xorg-server/include/dix.h
+++ b/xorg-server/include/dix.h
@@ -254,6 +254,12 @@ extern _X_EXPORT void ClientWakeup(ClientPtr /*client */ );
 
 extern _X_EXPORT Bool ClientIsAsleep(ClientPtr /*client */ );
 
+extern _X_EXPORT void SendGraphicsExpose(ClientPtr /*client */ ,
+                                         RegionPtr /*pRgn */ ,
+                                         XID /*drawable */ ,
+                                         int /*major */ ,
+                                         int  /*minor */);
+
 /* atom.c */
 
 extern _X_EXPORT Atom MakeAtom(const char * /*string */ ,
diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h
index f3473ec6b..d30333a88 100755
--- a/xorg-server/include/input.h
+++ b/xorg-server/include/input.h
@@ -287,9 +287,6 @@ extern _X_EXPORT int dixLookupDevice(DeviceIntPtr * /* dev */ ,
 extern _X_EXPORT void QueryMinMaxKeyCodes(KeyCode * /*minCode */ ,
                                           KeyCode * /*maxCode */ );
 
-extern _X_EXPORT Bool SetKeySymsMap(KeySymsPtr /*dst */ ,
-                                    KeySymsPtr /*src */ );
-
 extern _X_EXPORT Bool InitButtonClassDeviceStruct(DeviceIntPtr /*device */ ,
                                                   int /*numButtons */ ,
                                                   Atom * /* labels */ ,
diff --git a/xorg-server/include/scrnintstr.h b/xorg-server/include/scrnintstr.h
index 024d9e5c2..444340ca8 100755
--- a/xorg-server/include/scrnintstr.h
+++ b/xorg-server/include/scrnintstr.h
@@ -155,8 +155,7 @@ typedef void (*PostValidateTreeProcPtr) (WindowPtr /*pParent */ ,
                                          VTKind /*kind */ );
 
 typedef void (*WindowExposuresProcPtr) (WindowPtr /*pWindow */ ,
-                                        RegionPtr /*prgn */ ,
-                                        RegionPtr /*other_exposed */ );
+                                        RegionPtr /*prgn */);
 
 typedef void (*CopyWindowProcPtr) (WindowPtr /*pWindow */ ,
                                    DDXPointRec /*ptOldOrg */ ,
@@ -253,12 +252,6 @@ typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ ,
 
 typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ );
 
-typedef void (*SendGraphicsExposeProcPtr) (ClientPtr /*client */ ,
-                                           RegionPtr /*pRgn */ ,
-                                           XID /*drawable */ ,
-                                           int /*major */ ,
-                                           int /*minor */ );
-
 typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen,
                                            void *pTimeout,
                                            void *pReadmask);
@@ -545,7 +538,6 @@ typedef struct _Screen {
     /* Region procedures */
 
     BitmapToRegionProcPtr BitmapToRegion;
-    SendGraphicsExposeProcPtr SendGraphicsExpose;
 
     /* os layer procedures */
 
diff --git a/xorg-server/include/windowstr.h b/xorg-server/include/windowstr.h
index e06418659..3afdec091 100644
--- a/xorg-server/include/windowstr.h
+++ b/xorg-server/include/windowstr.h
@@ -144,14 +144,13 @@ typedef struct _Window {
     Mask eventMask;             /* mask from the creating client */
     PixUnion background;
     PixUnion border;
-    void *backStorage;          /* null when BS disabled */
     WindowOptPtr optional;
     unsigned backgroundState:2; /* None, Relative, Pixel, Pixmap */
     unsigned borderIsPixel:1;
     unsigned cursorIsNone:1;    /* else real cursor (might inherit) */
     unsigned backingStore:2;
+    unsigned backStorage:1;     /* if bs is allocated */
     unsigned saveUnder:1;
-    unsigned DIXsaveUnder:1;
     unsigned bitGravity:4;
     unsigned winGravity:4;
     unsigned overrideRedirect:1;
diff --git a/xorg-server/mi/makefile b/xorg-server/mi/makefile
index 7067c62e8..fc6d57393 100644
--- a/xorg-server/mi/makefile
+++ b/xorg-server/mi/makefile
@@ -36,4 +36,5 @@ CSRCS=miarc.c		\
   
 LIBRARY=libmi
 
+INCLUDES+=../composite
 
diff --git a/xorg-server/mi/mi.h b/xorg-server/mi/mi.h
index d5a5ba374..5a455c910 100755
--- a/xorg-server/mi/mi.h
+++ b/xorg-server/mi/mi.h
@@ -229,15 +229,7 @@ extern _X_EXPORT RegionPtr miHandleExposures(DrawablePtr /*pSrcDrawable */ ,
                                              int /*width */ ,
                                              int /*height */ ,
                                              int /*dstx */ ,
-                                             int /*dsty */ ,
-                                             unsigned long      /*plane */
-    );
-
-extern _X_EXPORT void miSendGraphicsExpose(ClientPtr /*client */ ,
-                                           RegionPtr /*pRgn */ ,
-                                           XID /*drawable */ ,
-                                           int /*major */ ,
-                                           int  /*minor */
+                                             int /*dsty */
     );
 
 extern _X_EXPORT void miSendExposures(WindowPtr /*pWin */ ,
@@ -247,9 +239,7 @@ extern _X_EXPORT void miSendExposures(WindowPtr /*pWin */ ,
     );
 
 extern _X_EXPORT void miWindowExposures(WindowPtr /*pWin */ ,
-                                        RegionPtr /*prgn */ ,
-                                        RegionPtr       /*other_exposed */
-    );
+                                        RegionPtr /*prgn */);
 
 extern _X_EXPORT void miPaintWindow(WindowPtr /*pWin */ ,
                                     RegionPtr /*prgn */ ,
@@ -427,17 +417,6 @@ extern _X_EXPORT int miShapedWindowIn(RegionPtr /*universe */ ,
                                       int       /*y */
     );
 
-typedef void
- (*SetRedirectBorderClipProcPtr) (WindowPtr pWindow, RegionPtr pRegion);
-
-typedef RegionPtr
- (*GetRedirectBorderClipProcPtr) (WindowPtr pWindow);
-
-extern _X_EXPORT void
-
-miRegisterRedirectBorderClipProc(SetRedirectBorderClipProcPtr setBorderClip,
-                                 GetRedirectBorderClipProcPtr getBorderClip);
-
 extern _X_EXPORT int miValidateTree(WindowPtr /*pParent */ ,
                                     WindowPtr /*pChild */ ,
                                     VTKind      /*kind */
@@ -491,12 +470,12 @@ extern _X_EXPORT void miMoveWindow(WindowPtr /*pWin */ ,
                                    VTKind       /*kind */
     );
 
-extern _X_EXPORT void miSlideAndSizeWindow(WindowPtr /*pWin */ ,
-                                           int /*x */ ,
-                                           int /*y */ ,
-                                           unsigned int /*w */ ,
-                                           unsigned int /*h */ ,
-                                           WindowPtr    /*pSib */
+extern _X_EXPORT void miResizeWindow(WindowPtr /*pWin */ ,
+                                     int /*x */ ,
+                                     int /*y */ ,
+                                     unsigned int /*w */ ,
+                                     unsigned int /*h */ ,
+                                     WindowPtr    /*pSib */
     );
 
 extern _X_EXPORT WindowPtr miGetLayerWindow(WindowPtr   /*pWin */
diff --git a/xorg-server/mi/mibitblt.c b/xorg-server/mi/mibitblt.c
index 3ed4ed1cc..08bd1c5b2 100644
--- a/xorg-server/mi/mibitblt.c
+++ b/xorg-server/mi/mibitblt.c
@@ -242,8 +242,7 @@ miCopyArea(DrawablePtr pSrcDrawable,
         }
     }
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
-                                    widthSrc, heightSrc, xOut, yOut,
-                                    (unsigned long) 0);
+                                    widthSrc, heightSrc, xOut, yOut);
     if (realSrcClip)
         RegionDestroy(prgnSrcClip);
 
@@ -579,7 +578,7 @@ miCopyPlane(DrawablePtr pSrcDrawable,
         }
     }
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
-                                    width, height, dstx, dsty, bitPlane);
+                                    width, height, dstx, dsty);
     RegionDestroy(prgnSrc);
     return prgnExposed;
 }
diff --git a/xorg-server/mi/micmap.c b/xorg-server/mi/micmap.c
index e2653cc1f..ff8a0322e 100644
--- a/xorg-server/mi/micmap.c
+++ b/xorg-server/mi/micmap.c
@@ -244,42 +244,7 @@ miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem * indefs,
 Bool
 miCreateDefColormap(ScreenPtr pScreen)
 {
-/* 
- * In the following sources PC X server vendors may want to delete 
- * "_not_tog" from "#ifdef WIN32_not_tog"
- */
-#ifdef WIN32_not_tog
-    /*  
-     * these are the MS-Windows desktop colors, adjusted for X's 16-bit 
-     * color specifications.
-     */
-    static xColorItem citems[] = {
-        {0, 0, 0, 0, 0, 0},
-        {1, 0x8000, 0, 0, 0, 0},
-        {2, 0, 0x8000, 0, 0, 0},
-        {3, 0x8000, 0x8000, 0, 0, 0},
-        {4, 0, 0, 0x8000, 0, 0},
-        {5, 0x8000, 0, 0x8000, 0, 0},
-        {6, 0, 0x8000, 0x8000, 0, 0},
-        {7, 0xc000, 0xc000, 0xc000, 0, 0},
-        {8, 0xc000, 0xdc00, 0xc000, 0, 0},
-        {9, 0xa600, 0xca00, 0xf000, 0, 0},
-        {246, 0xff00, 0xfb00, 0xf000, 0, 0},
-        {247, 0xa000, 0xa000, 0xa400, 0, 0},
-        {248, 0x8000, 0x8000, 0x8000, 0, 0},
-        {249, 0xff00, 0, 0, 0, 0},
-        {250, 0, 0xff00, 0, 0, 0},
-        {251, 0xff00, 0xff00, 0, 0, 0},
-        {252, 0, 0, 0xff00, 0, 0},
-        {253, 0xff00, 0, 0xff00, 0, 0},
-        {254, 0, 0xff00, 0xff00, 0, 0},
-        {255, 0xff00, 0xff00, 0xff00, 0, 0}
-    };
-#define NUM_DESKTOP_COLORS sizeof citems / sizeof citems[0]
-    int i;
-#else
     unsigned short zero = 0, ones = 0xFFFF;
-#endif
     Pixel wp, bp;
     VisualPtr pVisual;
     ColormapPtr cmap;
@@ -303,21 +268,12 @@ miCreateDefColormap(ScreenPtr pScreen)
     if (pScreen->rootDepth > 1) {
         wp = pScreen->whitePixel;
         bp = pScreen->blackPixel;
-#ifdef WIN32_not_tog
-        for (i = 0; i < NUM_DESKTOP_COLORS; i++) {
-            if (AllocColor(cmap,
-                           &citems[i].red, &citems[i].green, &citems[i].blue,
-                           &citems[i].pixel, 0) != Success)
-                return FALSE;
-        }
-#else
         if ((AllocColor(cmap, &ones, &ones, &ones, &wp, 0) !=
              Success) ||
             (AllocColor(cmap, &zero, &zero, &zero, &bp, 0) != Success))
             return FALSE;
         pScreen->whitePixel = wp;
         pScreen->blackPixel = bp;
-#endif
     }
 
     (*pScreen->InstallColormap) (cmap);
diff --git a/xorg-server/mi/micopy.c b/xorg-server/mi/micopy.c
index 30795114d..a52b0a786 100644
--- a/xorg-server/mi/micopy.c
+++ b/xorg-server/mi/micopy.c
@@ -304,8 +304,7 @@ miDoCopy(DrawablePtr pSrcDrawable,
                                         yIn - pSrcDrawable->y,
                                         widthSrc, heightSrc,
                                         xOut - pDstDrawable->x,
-                                        yOut - pDstDrawable->y,
-                                        (unsigned long) bitPlane);
+                                        yOut - pDstDrawable->y);
     RegionUninit(&rgnDst);
     if (freeSrcClip)
         RegionDestroy(prgnSrcClip);
diff --git a/xorg-server/mi/miexpose.c b/xorg-server/mi/miexpose.c
index 68d846fb6..de8ee6c2a 100644..100755
--- a/xorg-server/mi/miexpose.c
+++ b/xorg-server/mi/miexpose.c
@@ -116,18 +116,12 @@ NOTE:
      this should generally be called, even if graphicsExposures is false,
 because this is where bits get recovered from backing store.
 
-NOTE:
-     added argument 'plane' is used to indicate how exposures from backing
-store should be accomplished. If plane is 0 (i.e. no bit plane), CopyArea
-should be used, else a CopyPlane of the indicated plane will be used. The
-exposing is done by the backing store's GraphicsExpose function, of course.
-
 */
 
 RegionPtr
 miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
                   GCPtr pGC, int srcx, int srcy, int width, int height,
-                  int dstx, int dsty, unsigned long plane)
+                  int dstx, int dsty)
 {
     RegionPtr prgnSrcClip;      /* drawable-relative source clip */
     RegionRec rgnSrcRec;
@@ -149,7 +143,7 @@ miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
     if (!pGC->graphicsExposures &&
         (pDstDrawable->type == DRAWABLE_PIXMAP) &&
         ((pSrcDrawable->type == DRAWABLE_PIXMAP) ||
-         (((WindowPtr) pSrcDrawable)->backStorage == NULL)))
+         (((WindowPtr) pSrcDrawable)->backStorage == 0)))
         return NULL;
 
     srcBox.x1 = srcx;
@@ -312,53 +306,6 @@ miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
     }
 }
 
-/* send GraphicsExpose events, or a NoExpose event, based on the region */
-
-void
-miSendGraphicsExpose(ClientPtr client, RegionPtr pRgn, XID drawable,
-                     int major, int minor)
-{
-    if (pRgn && !RegionNil(pRgn)) {
-        xEvent *pEvent;
-        xEvent *pe;
-        BoxPtr pBox;
-        int i;
-        int numRects;
-
-        numRects = RegionNumRects(pRgn);
-        pBox = RegionRects(pRgn);
-        if (!(pEvent = calloc(numRects, sizeof(xEvent))))
-            return;
-        pe = pEvent;
-
-        for (i = 1; i <= numRects; i++, pe++, pBox++) {
-            pe->u.u.type = GraphicsExpose;
-            pe->u.graphicsExposure.drawable = drawable;
-            pe->u.graphicsExposure.x = pBox->x1;
-            pe->u.graphicsExposure.y = pBox->y1;
-            pe->u.graphicsExposure.width = pBox->x2 - pBox->x1;
-            pe->u.graphicsExposure.height = pBox->y2 - pBox->y1;
-            pe->u.graphicsExposure.count = numRects - i;
-            pe->u.graphicsExposure.majorEvent = major;
-            pe->u.graphicsExposure.minorEvent = minor;
-        }
-        /* GraphicsExpose is a "critical event", which TryClientEvents
-         * handles specially. */
-        TryClientEvents(client, NULL, pEvent, numRects,
-                        (Mask) 0, NoEventMask, NullGrab);
-        free(pEvent);
-    }
-    else {
-        xEvent event; memset(&event, 0, sizeof(xEvent));
-        event.u.noExposure.drawable = drawable;
-        event.u.noExposure.majorEvent = major;
-        event.u.noExposure.minorEvent = minor;
-        
-        event.u.u.type = NoExpose;
-        WriteEventsToClient(client, 1, &event);
-    }
-}
-
 void
 miSendExposures(WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
 {
@@ -421,30 +368,15 @@ miSendExposures(WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
 }
 
 void
-miWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr other_exposed)
+miWindowExposures(WindowPtr pWin, RegionPtr prgn)
 {
     RegionPtr exposures = prgn;
 
-    if ((prgn && !RegionNil(prgn)) ||
-        (exposures && !RegionNil(exposures)) || other_exposed) {
+    if (prgn && !RegionNil(prgn)) {
         RegionRec expRec;
-        int clientInterested;
-
-        /*
-         * Restore from backing-store FIRST.
-         */
-        clientInterested =
+        int clientInterested =
             (pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
-        if (other_exposed) {
-            if (exposures) {
-                RegionUnion(other_exposed, exposures, other_exposed);
-                if (exposures != prgn)
-                    RegionDestroy(exposures);
-            }
-            exposures = other_exposed;
-        }
-        if (clientInterested && exposures &&
-            (RegionNumRects(exposures) > RECTLIMIT)) {
+        if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
             /*
              * If we have LOTS of rectangles, we decide to take the extents
              * and force an exposure on that.  This should require much less
@@ -453,34 +385,21 @@ miWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr other_exposed)
              */
             BoxRec box;
 
-            box = *RegionExtents(exposures);
-            if (exposures == prgn) {
-                exposures = &expRec;
-                RegionInit(exposures, &box, 1);
-                RegionReset(prgn, &box);
-            }
-            else {
-                RegionReset(exposures, &box);
-                RegionUnion(prgn, prgn, exposures);
-            }
+            box = *RegionExtents(prgn);
+            exposures = &expRec;
+            RegionInit(exposures, &box, 1);
+            RegionReset(prgn, &box);
             /* miPaintWindow doesn't clip, so we have to */
             RegionIntersect(prgn, prgn, &pWin->clipList);
         }
-        if (prgn && !RegionNil(prgn))
-            miPaintWindow(pWin, prgn, PW_BACKGROUND);
-        if (clientInterested && exposures && !RegionNil(exposures))
+        miPaintWindow(pWin, prgn, PW_BACKGROUND);
+        if (clientInterested)
             miSendExposures(pWin, exposures,
                             pWin->drawable.x, pWin->drawable.y);
-        if (exposures == &expRec) {
+        if (exposures == &expRec)
             RegionUninit(exposures);
-        }
-        else if (exposures && exposures != prgn && exposures != other_exposed)
-            RegionDestroy(exposures);
-        if (prgn)
-            RegionEmpty(prgn);
+        RegionEmpty(prgn);
     }
-    else if (exposures && exposures != prgn)
-        RegionDestroy(exposures);
 }
 
 #ifdef ROOTLESS
diff --git a/xorg-server/mi/mioverlay.c b/xorg-server/mi/mioverlay.c
index ef67f386d..9df98185b 100644
--- a/xorg-server/mi/mioverlay.c
+++ b/xorg-server/mi/mioverlay.c
@@ -83,7 +83,7 @@ static void miOverlayMarkUnrealizedWindow(WindowPtr, WindowPtr, Bool);
 static int miOverlayValidateTree(WindowPtr, WindowPtr, VTKind);
 static void miOverlayHandleExposures(WindowPtr);
 static void miOverlayMoveWindow(WindowPtr, int, int, WindowPtr, VTKind);
-static void miOverlayWindowExposures(WindowPtr, RegionPtr, RegionPtr);
+static void miOverlayWindowExposures(WindowPtr, RegionPtr);
 static void miOverlayResizeWindow(WindowPtr, int, int, unsigned int,
                                   unsigned int, WindowPtr);
 static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
@@ -831,7 +831,7 @@ miOverlayHandleExposures(WindowPtr pWin)
     miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
     WindowPtr pChild;
     ValidatePtr val;
-    void (*WindowExposures) (WindowPtr, RegionPtr, RegionPtr);
+    WindowExposuresProcPtr WindowExposures;
 
     WindowExposures = pWin->drawable.pScreen->WindowExposures;
     if (pPriv->underlayMarked) {
@@ -853,8 +853,7 @@ miOverlayHandleExposures(WindowPtr pWin)
                     }
                     RegionUninit(&mival->borderExposed);
 
-                    (*WindowExposures) (pTree->pWin, &mival->exposed,
-                                        NullRegion);
+                    (*WindowExposures) (pTree->pWin, &mival->exposed);
                     RegionUninit(&mival->exposed);
                 }
                 free(mival);
@@ -890,7 +889,7 @@ miOverlayHandleExposures(WindowPtr pWin)
                 if (RegionNotEmpty(&val->after.borderExposed)) {
                     miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
                 }
-                (*WindowExposures) (pChild, &val->after.exposed, NullRegion);
+                (*WindowExposures) (pChild, &val->after.exposed);
             }
             RegionUninit(&val->after.borderExposed);
             RegionUninit(&val->after.exposed);
@@ -984,42 +983,23 @@ miOverlayMoveWindow(WindowPtr pWin,
 #endif
 
 static void
-miOverlayWindowExposures(WindowPtr pWin,
-                         RegionPtr prgn, RegionPtr other_exposed)
+miOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn)
 {
     RegionPtr exposures = prgn;
 
-    if ((prgn && !RegionNil(prgn)) ||
-        (exposures && !RegionNil(exposures)) || other_exposed) {
+    if (prgn && !RegionNil(prgn)) {
         RegionRec expRec;
-        int clientInterested;
-
-        clientInterested = (pWin->eventMask | wOtherEventMasks(pWin)) &
-            ExposureMask;
-        if (other_exposed) {
-            if (exposures) {
-                RegionUnion(other_exposed, exposures, other_exposed);
-                if (exposures != prgn)
-                    RegionDestroy(exposures);
-            }
-            exposures = other_exposed;
-        }
-        if (clientInterested && exposures &&
-            (RegionNumRects(exposures) > RECTLIMIT)) {
+        int clientInterested =
+            (pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
+        if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
             ScreenPtr pScreen = pWin->drawable.pScreen;
             miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
             BoxRec box;
 
-            box = *RegionExtents(exposures);
-            if (exposures == prgn) {
-                exposures = &expRec;
-                RegionInit(exposures, &box, 1);
-                RegionReset(prgn, &box);
-            }
-            else {
-                RegionReset(exposures, &box);
-                RegionUnion(prgn, prgn, exposures);
-            }
+            box = *RegionExtents(prgn);
+            exposures = &expRec;
+            RegionInit(exposures, &box, 1);
+            RegionReset(prgn, &box);
             /* This is the only reason why we are replacing mi's version
                of this file */
 
@@ -1031,21 +1011,14 @@ miOverlayWindowExposures(WindowPtr pWin,
             else
                 RegionIntersect(prgn, prgn, &pWin->clipList);
         }
-        if (prgn && !RegionNil(prgn))
-            miPaintWindow(pWin, prgn, PW_BACKGROUND);
-        if (clientInterested && exposures && !RegionNil(exposures))
+        miPaintWindow(pWin, prgn, PW_BACKGROUND);
+        if (clientInterested)
             miSendExposures(pWin, exposures,
                             pWin->drawable.x, pWin->drawable.y);
-        if (exposures == &expRec) {
+        if (exposures == &expRec)
             RegionUninit(exposures);
-        }
-        else if (exposures && exposures != prgn && exposures != other_exposed)
-            RegionDestroy(exposures);
-        if (prgn)
-            RegionEmpty(prgn);
+        RegionEmpty(prgn);
     }
-    else if (exposures && exposures != prgn)
-        RegionDestroy(exposures);
 }
 
 typedef struct {
@@ -1495,11 +1468,7 @@ miOverlaySetShape(WindowPtr pWin, int kind)
 
         if (WasViewable) {
             (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL);
-
             (*pScreen->ValidateTree) (pWin->parent, NullWindow, VTOther);
-        }
-
-        if (WasViewable) {
             (*pScreen->HandleExposures) (pWin->parent);
             if (pScreen->PostValidateTree)
                 (*pScreen->PostValidateTree) (pWin->parent, NullWindow,
@@ -1596,7 +1565,6 @@ miOverlayClearToBackground(WindowPtr pWin,
     miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
     BoxRec box;
     RegionRec reg;
-    RegionPtr pBSReg = NullRegion;
     ScreenPtr pScreen = pWin->drawable.pScreen;
     miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
     RegionPtr clipList;
@@ -1640,12 +1608,10 @@ miOverlayClearToBackground(WindowPtr pWin,
 
     RegionIntersect(&reg, &reg, clipList);
     if (generateExposures)
-        (*pScreen->WindowExposures) (pWin, &reg, pBSReg);
+        (*pScreen->WindowExposures) (pWin, &reg);
     else if (pWin->backgroundState != None)
         miPaintWindow(pWin, &reg, PW_BACKGROUND);
     RegionUninit(&reg);
-    if (pBSReg)
-        RegionDestroy(pBSReg);
 }
 
 /****************************************************************/
diff --git a/xorg-server/mi/miscrinit.c b/xorg-server/mi/miscrinit.c
index 00c15f713..327bd1540 100644
--- a/xorg-server/mi/miscrinit.c
+++ b/xorg-server/mi/miscrinit.c
@@ -259,13 +259,12 @@ miScreenInit(ScreenPtr pScreen, void *pbits,  /* pointer to screen bits */
     /* CreateColormap, DestroyColormap, InstallColormap, UninstallColormap */
     /* ListInstalledColormaps, StoreColors, ResolveColor */
     /* BitmapToRegion */
-    pScreen->SendGraphicsExpose = miSendGraphicsExpose;
     pScreen->BlockHandler = (ScreenBlockHandlerProcPtr) NoopDDA;
     pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr) NoopDDA;
     pScreen->MarkWindow = miMarkWindow;
     pScreen->MarkOverlappedWindows = miMarkOverlappedWindows;
     pScreen->MoveWindow = miMoveWindow;
-    pScreen->ResizeWindow = miSlideAndSizeWindow;
+    pScreen->ResizeWindow = miResizeWindow;
     pScreen->GetLayerWindow = miGetLayerWindow;
     pScreen->HandleExposures = miHandleValidateExposures;
     pScreen->ReparentWindow = (ReparentWindowProcPtr) 0;
diff --git a/xorg-server/mi/mivaltree.c b/xorg-server/mi/mivaltree.c
index 88f9a4084..c49560e0b 100644
--- a/xorg-server/mi/mivaltree.c
+++ b/xorg-server/mi/mivaltree.c
@@ -99,8 +99,10 @@ Equipment Corporation.
 #include    "mi.h"
 #include    "regionstr.h"
 #include    "mivalidate.h"
-
 #include    "globals.h"
+#ifdef COMPOSITE
+#include    "compint.h"
+#endif
 
 /*
  * Compute the visibility of a shaped window
@@ -160,17 +162,6 @@ miShapedWindowIn(RegionPtr universe, RegionPtr bounding,
     return rgnOUT;
 }
 
-static GetRedirectBorderClipProcPtr miGetRedirectBorderClipProc;
-static SetRedirectBorderClipProcPtr miSetRedirectBorderClipProc;
-
-void
-miRegisterRedirectBorderClipProc(SetRedirectBorderClipProcPtr setBorderClip,
-                                 GetRedirectBorderClipProcPtr getBorderClip)
-{
-    miSetRedirectBorderClipProc = setBorderClip;
-    miGetRedirectBorderClipProc = getBorderClip;
-}
-
 /*
  * Manual redirected windows are treated as transparent; they do not obscure
  * siblings or parent windows
@@ -242,11 +233,9 @@ miComputeClips(WindowPtr pParent,
      * In redirected drawing case, reset universe to borderSize
      */
     if (pParent->redirectDraw != RedirectDrawNone) {
-        if (miSetRedirectBorderClipProc) {
-            if (TreatAsTransparent(pParent))
-                RegionEmpty(universe);
-            (*miSetRedirectBorderClipProc) (pParent, universe);
-        }
+        if (TreatAsTransparent(pParent))
+            RegionEmpty(universe);
+        compSetRedirectBorderClip (pParent, universe);
         RegionCopy(universe, &pParent->borderSize);
     }
 #endif
@@ -519,6 +508,17 @@ miTreeObscured(WindowPtr pParent)
     }
 }
 
+static RegionPtr
+getBorderClip(WindowPtr pWin)
+{
+#ifdef COMPOSITE
+    if (pWin->redirectDraw != RedirectDrawNone)
+        return compGetRedirectBorderClip(pWin);
+    else
+#endif
+        return &pWin->borderClip;
+}
+
 /*
  *-----------------------------------------------------------------------
  * miValidateTree --
@@ -612,14 +612,7 @@ miValidateTree(WindowPtr pParent,       /* Parent to validate */
             forward = TRUE;
             for (pWin = pChild; pWin; pWin = pWin->nextSib) {
                 if (pWin->valdata) {
-                    RegionPtr pBorderClip = &pWin->borderClip;
-
-#ifdef COMPOSITE
-                    if (pWin->redirectDraw != RedirectDrawNone &&
-                        miGetRedirectBorderClipProc)
-                        pBorderClip = (*miGetRedirectBorderClipProc) (pWin);
-#endif
-                    RegionAppend(&totalClip, pBorderClip);
+                    RegionAppend(&totalClip, getBorderClip(pWin));
                     if (pWin->viewable)
                         viewvals++;
                 }
@@ -630,14 +623,7 @@ miValidateTree(WindowPtr pParent,       /* Parent to validate */
             pWin = pParent->lastChild;
             while (1) {
                 if (pWin->valdata) {
-                    RegionPtr pBorderClip = &pWin->borderClip;
-
-#ifdef COMPOSITE
-                    if (pWin->redirectDraw != RedirectDrawNone &&
-                        miGetRedirectBorderClipProc)
-                        pBorderClip = (*miGetRedirectBorderClipProc) (pWin);
-#endif
-                    RegionAppend(&totalClip, pBorderClip);
+                    RegionAppend(&totalClip, getBorderClip(pWin));
                     if (pWin->viewable)
                         viewvals++;
                 }
diff --git a/xorg-server/mi/miwindow.c b/xorg-server/mi/miwindow.c
index 31b196fe7..d5690b616 100644
--- a/xorg-server/mi/miwindow.c
+++ b/xorg-server/mi/miwindow.c
@@ -111,7 +111,7 @@ miClearToBackground(WindowPtr pWin,
 
     RegionIntersect(&reg, &reg, &pWin->clipList);
     if (generateExposures)
-        (*pWin->drawable.pScreen->WindowExposures) (pWin, &reg, NULL);
+        (*pWin->drawable.pScreen->WindowExposures) (pWin, &reg);
     else if (pWin->backgroundState != None)
         miPaintWindow(pWin, &reg, PW_BACKGROUND);
     RegionUninit(&reg);
@@ -221,7 +221,7 @@ miHandleValidateExposures(WindowPtr pWin)
             if (RegionNotEmpty(&val->after.borderExposed))
                 miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
             RegionUninit(&val->after.borderExposed);
-            (*WindowExposures) (pChild, &val->after.exposed, NullRegion);
+            (*WindowExposures) (pChild, &val->after.exposed);
             RegionUninit(&val->after.exposed);
             free(val);
             pChild->valdata = NULL;
@@ -292,9 +292,9 @@ miMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pNextSib, VTKind kind)
             RegionDestroy(oldRegion);
             /* XXX need to retile border if ParentRelative origin */
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, NULL, kind);
         }
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, NullWindow, kind);
     }
     if (pWin->realized)
         WindowsRestructured();
@@ -337,9 +337,8 @@ miRecomputeExposures(WindowPtr pWin, void *value)
 }
 
 void
-miSlideAndSizeWindow(WindowPtr pWin,
-                     int x, int y,
-                     unsigned int w, unsigned int h, WindowPtr pSib)
+miResizeWindow(WindowPtr pWin, int x, int y, unsigned int w, unsigned int h,
+               WindowPtr pSib)
 {
     WindowPtr pParent;
     Bool WasViewable = (Bool) (pWin->viewable);
@@ -608,11 +607,12 @@ miSlideAndSizeWindow(WindowPtr pWin,
         RegionDestroy(pRegion);
         if (destClip)
             RegionDestroy(destClip);
-        if (anyMarked)
+        if (anyMarked) {
             (*pScreen->HandleExposures) (pLayerWin->parent);
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
-                                          VTOther);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
+                                              VTOther);
+        }
     }
     if (pWin->realized)
         WindowsRestructured();
@@ -664,17 +664,14 @@ miSetShape(WindowPtr pWin, int kind)
         if (WasViewable) {
             anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL);
 
-            if (anyMarked)
+            if (anyMarked) {
                 (*pScreen->ValidateTree) (pLayerWin->parent, NullWindow,
                                           VTOther);
-        }
-
-        if (WasViewable) {
-            if (anyMarked)
                 (*pScreen->HandleExposures) (pLayerWin->parent);
-            if (anyMarked && pScreen->PostValidateTree)
-                (*pScreen->PostValidateTree) (pLayerWin->parent, NullWindow,
-                                              VTOther);
+                if (pScreen->PostValidateTree)
+                    (*pScreen->PostValidateTree) (pLayerWin->parent, NULL,
+                                                  VTOther);
+            }
         }
     }
     if (pWin->realized)
@@ -726,10 +723,10 @@ miChangeBorderWidth(WindowPtr pWin, unsigned int width)
         if (anyMarked) {
             (*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTOther);
             (*pScreen->HandleExposures) (pLayerWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
+                                              VTOther);
         }
-        if (anyMarked && pScreen->PostValidateTree)
-            (*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
-                                          VTOther);
     }
     if (pWin->realized)
         WindowsRestructured();
diff --git a/xorg-server/miext/rootless/rootlessValTree.c b/xorg-server/miext/rootless/rootlessValTree.c
index 730d2917e..c7c2c9935 100644
--- a/xorg-server/miext/rootless/rootlessValTree.c
+++ b/xorg-server/miext/rootless/rootlessValTree.c
@@ -106,64 +106,6 @@ Equipment Corporation.
 
 int RootlessMiValidateTree(WindowPtr pRoot, WindowPtr pChild, VTKind kind);
 
-/*
- * Compute the visibility of a shaped window
- */
-static int
-RootlessShapedWindowIn(RegionPtr universe,
-                       RegionPtr bounding, BoxPtr rect, int x, int y)
-{
-    BoxRec box;
-    register BoxPtr boundBox;
-    int nbox;
-    Bool someIn, someOut;
-    register int t, x1, y1, x2, y2;
-
-    nbox = RegionNumRects(bounding);
-    boundBox = RegionRects(bounding);
-    someIn = someOut = FALSE;
-    x1 = rect->x1;
-    y1 = rect->y1;
-    x2 = rect->x2;
-    y2 = rect->y2;
-    while (nbox--) {
-        if ((t = boundBox->x1 + x) < x1)
-            t = x1;
-        box.x1 = t;
-        if ((t = boundBox->y1 + y) < y1)
-            t = y1;
-        box.y1 = t;
-        if ((t = boundBox->x2 + x) > x2)
-            t = x2;
-        box.x2 = t;
-        if ((t = boundBox->y2 + y) > y2)
-            t = y2;
-        box.y2 = t;
-        if (box.x1 > box.x2)
-            box.x2 = box.x1;
-        if (box.y1 > box.y2)
-            box.y2 = box.y1;
-        switch (RegionContainsRect(universe, &box)) {
-        case rgnIN:
-            if (someOut)
-                return rgnPART;
-            someIn = TRUE;
-            break;
-        case rgnOUT:
-            if (someIn)
-                return rgnPART;
-            someOut = TRUE;
-            break;
-        default:
-            return rgnPART;
-        }
-        boundBox++;
-    }
-    if (someIn)
-        return rgnIN;
-    return rgnOUT;
-}
-
 #define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
 				    HasBorder(w) && \
 				    (w)->backgroundState == ParentRelative)
@@ -229,10 +171,9 @@ RootlessComputeClips(WindowPtr pParent, ScreenPtr pScreen,
             RegionPtr pBounding;
 
             if ((pBounding = wBoundingShape(pParent))) {
-                switch (RootlessShapedWindowIn(universe,
-                                               pBounding, &borderSize,
-                                               pParent->drawable.x,
-                                               pParent->drawable.y)) {
+                switch (miShapedWindowIn(universe, pBounding, &borderSize,
+                                         pParent->drawable.x,
+                                         pParent->drawable.y)) {
                 case rgnIN:
                     newVis = VisibilityUnobscured;
                     break;
diff --git a/xorg-server/present/present.c b/xorg-server/present/present.c
index e82cfe656..2627d95b9 100644
--- a/xorg-server/present/present.c
+++ b/xorg-server/present/present.c
@@ -767,7 +767,7 @@ present_pixmap(WindowPtr window,
      * in the same frame
      */
 
-    if (!update) {
+    if (!update && pixmap) {
         xorg_list_for_each_entry_safe(vblank, tmp, &window_priv->vblank, window_list) {
 
             if (!vblank->pixmap)
diff --git a/xorg-server/test/xi2/protocol-common.c b/xorg-server/test/xi2/protocol-common.c
index 9a429e49f..9265ba390 100644
--- a/xorg-server/test/xi2/protocol-common.c
+++ b/xorg-server/test/xi2/protocol-common.c
@@ -25,6 +25,7 @@
 #include <dix-config.h>
 #endif
 
+#include <errno.h>
 #include <stdint.h>
 #include "extinit.h"            /* for XInputExtensionInit */
 #include "exglobals.h"
@@ -137,6 +138,18 @@ init_devices(void)
 {
     ClientRec client;
     struct devices local_devices;
+    int ret;
+
+    /*
+     * Put a unique name in display pointer so that when tests are run in
+     * parallel, their xkbcomp outputs to /tmp/server-<display>.xkm don't
+     * stomp on each other.
+     */
+#ifdef HAVE_GETPROGNAME
+    display = getprogname();
+#elif HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
+    display = program_invocation_short_name;
+#endif
 
     client = init_client(0, NULL);
 
@@ -145,15 +158,20 @@ init_devices(void)
     inputInfo.pointer = local_devices.vcp;
 
     inputInfo.keyboard = local_devices.vck;
-    ActivateDevice(local_devices.vcp, FALSE);
-    ActivateDevice(local_devices.vck, FALSE);
+    ret = ActivateDevice(local_devices.vcp, FALSE);
+    assert(ret == Success);
+    /* This may fail if xkbcomp fails or xkb-config is not found. */
+    ret = ActivateDevice(local_devices.vck, FALSE);
+    assert(ret == Success);
     EnableDevice(local_devices.vcp, FALSE);
     EnableDevice(local_devices.vck, FALSE);
 
     AllocDevicePair(&client, "", &local_devices.mouse, &local_devices.kbd,
                     TestPointerProc, CoreKeyboardProc, FALSE);
-    ActivateDevice(local_devices.mouse, FALSE);
-    ActivateDevice(local_devices.kbd, FALSE);
+    ret = ActivateDevice(local_devices.mouse, FALSE);
+    assert(ret == Success);
+    ret = ActivateDevice(local_devices.kbd, FALSE);
+    assert(ret == Success);
     EnableDevice(local_devices.mouse, FALSE);
     EnableDevice(local_devices.kbd, FALSE);