mkfontscale pixman xserver xtrans libX11 libXdmcp libxcb libXmu mesa git update 5 oct 2011

71 files changed, 9175 insertions, 8380 deletions

diff --git a/xorg-server/Xext/xcmisc.c b/xorg-server/Xext/xcmisc.c
index 8e3c9cd80..745135ed5 100644
--- a/xorg-server/Xext/xcmisc.c
+++ b/xorg-server/Xext/xcmisc.c
@@ -40,12 +40,7 @@ from The Open Group.
 #include <X11/extensions/xcmiscproto.h>
 #include "modinit.h"
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
-
 
 static int
 ProcXCMiscGetVersion(ClientPtr client)
diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c
index 38089a27c..74a78ecf2 100644
--- a/xorg-server/Xi/exevents.c
+++ b/xorg-server/Xi/exevents.c
@@ -774,12 +774,9 @@ UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
 
     for (i = 0; i <= last_valuator && i < v->numAxes; i++)
     {
+        /* XXX: Relative/Absolute mode */
         if (BitIsOn(&event->valuators.mask, i))
-        {
-            /* XXX: Relative/Absolute mode */
             v->axisVal[i] = event->valuators.data[i];
-            v->axisVal[i] += (event->valuators.data_frac[i] * 1.0f / (1 << 16) / (1 << 16));
-        }
     }
 
     if (event->type == ET_KeyPress) {
@@ -1070,16 +1067,16 @@ InitProximityClassDeviceStruct(DeviceIntPtr dev)
  *
  * @see InitValuatorClassDeviceStruct
  */
-void
+Bool
 InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int maxval,
 		       int resolution, int min_res, int max_res, int mode)
 {
     AxisInfoPtr ax;
 
-    if (!dev || !dev->valuator || minval > maxval)
-        return;
+    if (!dev || !dev->valuator || (minval > maxval && mode == Absolute))
+        return FALSE;
     if (axnum >= dev->valuator->numAxes)
-        return;
+        return FALSE;
 
     ax = dev->valuator->axes + axnum;
 
@@ -1093,6 +1090,57 @@ InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int
 
     if (mode & OutOfProximity)
         dev->proximity->in_proximity = FALSE;
+
+    return SetScrollValuator(dev, axnum, SCROLL_TYPE_NONE, 0, SCROLL_FLAG_NONE);
+}
+
+/**
+ * Set the given axis number as a scrolling valuator.
+ */
+Bool
+SetScrollValuator(DeviceIntPtr dev, int axnum, enum ScrollType type, double increment, int flags)
+{
+    AxisInfoPtr ax;
+    int *current_ax;
+
+    if (!dev || !dev->valuator || axnum >= dev->valuator->numAxes)
+        return FALSE;
+
+    switch (type)
+    {
+        case SCROLL_TYPE_VERTICAL:
+            current_ax = &dev->valuator->v_scroll_axis;
+            break;
+        case SCROLL_TYPE_HORIZONTAL:
+            current_ax = &dev->valuator->h_scroll_axis;
+            break;
+        case SCROLL_TYPE_NONE:
+            ax = &dev->valuator->axes[axnum];
+            ax->scroll.type = type;
+            return TRUE;
+        default:
+            return FALSE;
+    }
+
+    if (increment == 0.0)
+        return FALSE;
+
+    if (*current_ax != -1 && axnum != *current_ax)
+    {
+        ax = &dev->valuator->axes[*current_ax];
+        if (ax->scroll.type == type &&
+            (flags & SCROLL_FLAG_PREFERRED) && (ax->scroll.flags & SCROLL_FLAG_PREFERRED))
+            return FALSE;
+    }
+    *current_ax = axnum;
+
+    ax = &dev->valuator->axes[axnum];
+    ax->scroll.type = type;
+    ax->scroll.increment = increment;
+    ax->scroll.flags = flags;
+    /* FIXME: generate DeviceChanged Events */
+
+    return TRUE;
 }
 
 static void
diff --git a/xorg-server/Xi/xiproperty.c b/xorg-server/Xi/xiproperty.c
index fa0d81188..14f1491b6 100644
--- a/xorg-server/Xi/xiproperty.c
+++ b/xorg-server/Xi/xiproperty.c
@@ -52,11 +52,14 @@ static struct dev_properties
 } dev_properties[] = {
     {0, XI_PROP_ENABLED},
     {0, XI_PROP_XTEST_DEVICE},
+
     {0, XATOM_FLOAT},
+
     {0, ACCEL_PROP_PROFILE_NUMBER},
     {0, ACCEL_PROP_CONSTANT_DECELERATION},
     {0, ACCEL_PROP_ADAPTIVE_DECELERATION},
     {0, ACCEL_PROP_VELOCITY_SCALING},
+
     {0, AXIS_LABEL_PROP},
     {0, AXIS_LABEL_PROP_REL_X},
     {0, AXIS_LABEL_PROP_REL_Y},
@@ -68,6 +71,8 @@ static struct dev_properties
     {0, AXIS_LABEL_PROP_REL_DIAL},
     {0, AXIS_LABEL_PROP_REL_WHEEL},
     {0, AXIS_LABEL_PROP_REL_MISC},
+    {0, AXIS_LABEL_PROP_REL_VSCROLL},
+    {0, AXIS_LABEL_PROP_REL_HSCROLL},
     {0, AXIS_LABEL_PROP_ABS_X},
     {0, AXIS_LABEL_PROP_ABS_Y},
     {0, AXIS_LABEL_PROP_ABS_Z},
diff --git a/xorg-server/Xi/xiquerydevice.c b/xorg-server/Xi/xiquerydevice.c
index 902eb918c..9961d1b6f 100644
--- a/xorg-server/Xi/xiquerydevice.c
+++ b/xorg-server/Xi/xiquerydevice.c
@@ -229,7 +229,16 @@ SizeDeviceClasses(DeviceIntPtr dev)
     }
 
     if (dev->valuator)
-        len += sizeof(xXIValuatorInfo) * dev->valuator->numAxes;
+    {
+        int i;
+        len += (sizeof(xXIValuatorInfo)) * dev->valuator->numAxes;
+
+        for (i = 0; i < dev->valuator->numAxes; i++) {
+            if (dev->valuator->axes[i].scroll.type != SCROLL_TYPE_NONE)
+                len += sizeof(xXIScrollInfo);
+        }
+    }
+
 
     return len;
 }
@@ -369,6 +378,56 @@ SwapValuatorInfo(DeviceIntPtr dev, xXIValuatorInfo* info)
     swaps(&info->sourceid);
 }
 
+int
+ListScrollInfo(DeviceIntPtr dev, xXIScrollInfo *info, int axisnumber)
+{
+    ValuatorClassPtr v = dev->valuator;
+    AxisInfoPtr axis = &v->axes[axisnumber];
+
+    if (axis->scroll.type == SCROLL_TYPE_NONE)
+        return 0;
+
+    info->type = XIScrollClass;
+    info->length = sizeof(xXIScrollInfo)/4;
+    info->number = axisnumber;
+    switch(axis->scroll.type)
+    {
+        case SCROLL_TYPE_VERTICAL:
+            info->scroll_type = XIScrollTypeVertical;
+            break;
+        case SCROLL_TYPE_HORIZONTAL:
+            info->scroll_type = XIScrollTypeHorizontal;
+            break;
+        default:
+            ErrorF("[Xi] Unknown scroll type %d. This is a bug.\n", axis->scroll.type);
+            break;
+    }
+    info->increment.integral = (int)axis->scroll.increment;
+    info->increment.frac = (unsigned int)(axis->scroll.increment * (1UL << 16) * (1UL << 16));
+    info->sourceid = v->sourceid;
+
+    info->flags = 0;
+
+    if (axis->scroll.flags & SCROLL_FLAG_DONT_EMULATE)
+        info->flags |= XIScrollFlagNoEmulation;
+    if (axis->scroll.flags & SCROLL_FLAG_PREFERRED)
+        info->flags |= XIScrollFlagPreferred;
+
+    return info->length * 4;
+}
+
+static void
+SwapScrollInfo(DeviceIntPtr dev, xXIScrollInfo* info)
+{
+    swaps(&info->type);
+    swaps(&info->length);
+    swaps(&info->number);
+    swaps(&info->sourceid);
+    swaps(&info->scroll_type);
+    swapl(&info->increment.integral);
+    swapl(&info->increment.frac);
+}
+
 int GetDeviceUse(DeviceIntPtr dev, uint16_t *attachment)
 {
     DeviceIntPtr master = GetMaster(dev, MASTER_ATTACHED);
@@ -458,6 +517,15 @@ ListDeviceClasses(ClientPtr client, DeviceIntPtr dev,
         total_len += len;
     }
 
+    for (i = 0; dev->valuator && i < dev->valuator->numAxes; i++)
+    {
+        len = ListScrollInfo(dev, (xXIScrollInfo*)any, i);
+        if (len)
+            (*nclasses)++;
+        any += len;
+        total_len += len;
+    }
+
     return total_len;
 }
 
@@ -484,6 +552,9 @@ SwapDeviceInfo(DeviceIntPtr dev, xXIDeviceInfo* info)
             case XIValuatorClass:
                 SwapValuatorInfo(dev, (xXIValuatorInfo*)any);
                 break;
+            case XIScrollClass:
+                SwapScrollInfo(dev, (xXIScrollInfo*)any);
+                break;
         }
 
         any += len * 4;
diff --git a/xorg-server/Xi/xiquerydevice.h b/xorg-server/Xi/xiquerydevice.h
index 02f06591e..9db6aa293 100644
--- a/xorg-server/Xi/xiquerydevice.h
+++ b/xorg-server/Xi/xiquerydevice.h
@@ -44,4 +44,5 @@ int ListButtonInfo(DeviceIntPtr dev, xXIButtonInfo* info, Bool reportState);
 int ListKeyInfo(DeviceIntPtr dev, xXIKeyInfo* info);
 int ListValuatorInfo(DeviceIntPtr dev, xXIValuatorInfo* info,
 		     int axisnumber, Bool reportState);
+int ListScrollInfo(DeviceIntPtr dev, xXIScrollInfo* info, int axisnumber);
 #endif /* QUERYDEV_H */
diff --git a/xorg-server/Xi/xiwarppointer.c b/xorg-server/Xi/xiwarppointer.c
index 8fcb4d16b..11ab241b5 100644
--- a/xorg-server/Xi/xiwarppointer.c
+++ b/xorg-server/Xi/xiwarppointer.c
@@ -190,8 +190,6 @@ ProcXIWarpPointer(ClientPtr client)
     /* if we don't update the device, we get a jump next time it moves */
     pDev->last.valuators[0] = x;
     pDev->last.valuators[1] = y;
-    pDev->last.remainder[0] = 0;
-    pDev->last.remainder[1] = 0;
     miPointerUpdateSprite(pDev);
 
     /* FIXME: XWarpPointer is supposed to generate an event. It doesn't do it
diff --git a/xorg-server/config/Makefile.am b/xorg-server/config/Makefile.am
index 72d22346b..69bdcf730 100644
--- a/xorg-server/config/Makefile.am
+++ b/xorg-server/config/Makefile.am
@@ -1,41 +1,47 @@
-AM_CFLAGS = $(DIX_CFLAGS)

-

-noinst_LTLIBRARIES = libconfig.la

-libconfig_la_SOURCES = config.c config-backends.h

-

-if CONFIG_UDEV

-

-AM_CFLAGS += $(UDEV_CFLAGS)

-libconfig_la_SOURCES += udev.c

-libconfig_la_LIBADD = $(UDEV_LIBS)

-

-if XORG

-xorgconfddir = $(datadir)/X11/$(XF86CONFIGDIR)

-xorgconfd_DATA = 10-evdev.conf

-endif

-

-else

-

-if CONFIG_NEED_DBUS

-AM_CFLAGS += $(DBUS_CFLAGS)

-libconfig_la_SOURCES += dbus-core.c

-libconfig_la_LIBADD = $(DBUS_LIBS)

-

-if CONFIG_DBUS_API

-dbusconfigdir = $(sysconfdir)/dbus-1/system.d

-dbusconfig_DATA = xorg-server.conf

-

-libconfig_la_SOURCES += dbus.c

-endif

-

-if CONFIG_HAL

-AM_CFLAGS += $(HAL_CFLAGS)

-libconfig_la_SOURCES += hal.c

-libconfig_la_LIBADD += $(HAL_LIBS)

-endif

-

-endif # CONFIG_NEED_DBUS

-

-endif # !CONFIG_UDEV

-

-EXTRA_DIST = xorg-server.conf x11-input.fdi 10-evdev.conf fdi2iclass.py

+AM_CFLAGS = $(DIX_CFLAGS)
+
+noinst_LTLIBRARIES = libconfig.la
+libconfig_la_SOURCES = config.c config-backends.h
+
+if CONFIG_UDEV
+
+AM_CFLAGS += $(UDEV_CFLAGS)
+libconfig_la_SOURCES += udev.c
+libconfig_la_LIBADD = $(UDEV_LIBS)
+
+if XORG
+xorgconfddir = $(datadir)/X11/$(XF86CONFIGDIR)
+xorgconfd_DATA = 10-evdev.conf
+endif
+
+else
+
+if CONFIG_NEED_DBUS
+AM_CFLAGS += $(DBUS_CFLAGS)
+libconfig_la_SOURCES += dbus-core.c
+libconfig_la_LIBADD = $(DBUS_LIBS)
+
+if CONFIG_DBUS_API
+dbusconfigdir = $(sysconfdir)/dbus-1/system.d
+dbusconfig_DATA = xorg-server.conf
+
+libconfig_la_SOURCES += dbus.c
+endif
+
+if CONFIG_HAL
+AM_CFLAGS += $(HAL_CFLAGS)
+libconfig_la_SOURCES += hal.c
+libconfig_la_LIBADD += $(HAL_LIBS)
+endif
+
+else
+
+if CONFIG_WSCONS
+libconfig_la_SOURCES += wscons.c
+endif # CONFIG_WSCONS
+
+endif # CONFIG_NEED_DBUS
+
+endif # !CONFIG_UDEV
+
+EXTRA_DIST = xorg-server.conf x11-input.fdi 10-evdev.conf fdi2iclass.py
diff --git a/xorg-server/config/config-backends.h b/xorg-server/config/config-backends.h
index 35ab8a044..10743c38a 100644
--- a/xorg-server/config/config-backends.h
+++ b/xorg-server/config/config-backends.h
@@ -68,3 +68,8 @@ int config_hal_init(void);
 void config_hal_fini(void);
 # endif
 #endif
+
+#ifdef CONFIG_WSCONS
+int config_wscons_init(void);
+void config_wscons_fini(void);
+#endif
diff --git a/xorg-server/config/config.c b/xorg-server/config/config.c
index 9c28785c6..0dae3ad68 100644
--- a/xorg-server/config/config.c
+++ b/xorg-server/config/config.c
@@ -52,6 +52,9 @@ config_init(void)
     else {
 	ErrorF("[config] failed to initialise D-Bus core\n");
     }
+#elif defined(CONFIG_WSCONS)
+    if (!config_wscons_init())
+	ErrorF("[config] failed to initialise wscons\n");
 #endif
 }
 
@@ -68,6 +71,8 @@ config_fini(void)
     config_dbus_fini();
 # endif
     config_dbus_core_fini();
+#elif defined(CONFIG_WSCONS)
+    config_wscons_fini();
 #endif
 }
 
diff --git a/xorg-server/config/udev.c b/xorg-server/config/udev.c
index 1ba0d500d..e2b3726cc 100644
--- a/xorg-server/config/udev.c
+++ b/xorg-server/config/udev.c
@@ -285,8 +285,10 @@ config_udev_init(void)
     udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "input", NULL);
     udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL); /* For Wacom serial devices */
 
+#ifdef HAVE_UDEV_MONITOR_FILTER_ADD_MATCH_TAG
     if (SeatId && strcmp(SeatId, "seat0"))
         udev_monitor_filter_add_match_tag(udev_monitor, SeatId);
+#endif
 
     if (udev_monitor_enable_receiving(udev_monitor)) {
         ErrorF("config/udev: failed to bind the udev monitor\n");
@@ -300,8 +302,10 @@ config_udev_init(void)
     udev_enumerate_add_match_subsystem(enumerate, "input");
     udev_enumerate_add_match_subsystem(enumerate, "tty");
 
+#ifdef HAVE_UDEV_ENUMERATE_ADD_MATCH_TAG
     if (SeatId && strcmp(SeatId, "seat0"))
         udev_enumerate_add_match_tag(enumerate, SeatId);
+#endif
 
     udev_enumerate_scan_devices(enumerate);
     devices = udev_enumerate_get_list_entry(enumerate);
diff --git a/xorg-server/config/wscons.c b/xorg-server/config/wscons.c
new file mode 100644
index 000000000..27c1f6348
--- /dev/null
+++ b/xorg-server/config/wscons.c
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2011 Matthieu Herrb
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <dev/wscons/wsconsio.h>
+#include <dev/wscons/wsksymdef.h>
+
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "input.h"
+#include "inputstr.h"
+#include "os.h"
+#include "config-backends.h"
+
+#define WSCONS_KBD_DEVICE "/dev/wskbd"
+#define WSCONS_MOUSE_PREFIX "/dev/wsmouse"
+
+#define KB_OVRENC \
+	{ KB_UK,	"gb" }, \
+	{ KB_SV,	"se" }, \
+	{ KB_SG,	"ch" }, \
+	{ KB_SF,	"ch" }, \
+	{ KB_LA,	"latam" }, \
+	{ KB_CF,	"ca" }
+
+struct nameint {
+  int val;
+  char *name;
+} kbdenc[] = { KB_OVRENC, KB_ENCTAB, { 0 } };
+
+struct nameint kbdvar[] = {
+	{ KB_NODEAD | KB_SG,	"de_nodeadkeys" },
+	{ KB_NODEAD | KB_SF,	"fr_nodeadkeys" },
+	{ KB_SF,		"fr" },
+	{ KB_DVORAK | KB_CF,	"fr-dvorak" },
+	{ KB_DVORAK | KB_FR,	"bepo" },
+	{ KB_DVORAK,		"dvorak" },
+	{ KB_CF,		"fr-legacy" },
+	{ KB_NODEAD,		"nodeadkeys" },
+	{ 0 }
+};
+
+struct nameint kbdopt[] = {
+	{ KB_SWAPCTRLCAPS, "ctrl:swapcaps" },
+	{ 0 }
+};
+
+struct nameint kbdmodel[] = {
+	{ WSKBD_TYPE_ZAURUS,	"zaurus" },
+	{ 0 }
+};
+
+static void
+wscons_add_keyboard(void)
+{
+	InputAttributes attrs = {};
+	DeviceIntPtr dev = NULL;
+	InputOption *input_options = NULL;
+	char *config_info = NULL;
+	int fd, i, rc;
+	unsigned int type;
+	kbd_t wsenc = 0;
+
+	/* Find keyboard configuration */
+	fd = open(WSCONS_KBD_DEVICE, O_RDWR | O_NONBLOCK | O_EXCL);
+	if (fd == -1) {
+		LogMessage(X_ERROR, "wskbd: open %s: %s\n",
+		    WSCONS_KBD_DEVICE, strerror(errno));
+		return;
+	}
+	if (ioctl(fd, WSKBDIO_GETENCODING, &wsenc) == -1) {
+		LogMessage(X_WARNING, "wskbd: ioctl(WSKBDIO_GETENCODING) "
+		    "failed: %s\n", strerror(errno));
+		close(fd);
+		return;
+	}
+	if (ioctl(fd, WSKBDIO_GTYPE, &type) == -1) {
+		LogMessage(X_WARNING, "wskbd: ioctl(WSKBDIO_GTYPE) "
+		    "failed: %s\n", strerror(errno));
+		close(fd);
+		return;
+	}
+	close (fd);
+
+	input_options = input_option_new(input_options, "_source",
+	    "server/wscons");
+	if (input_options == NULL)
+		return;
+
+	LogMessage(X_INFO, "config/wscons: checking input device %s\n",
+	    WSCONS_KBD_DEVICE);
+	input_options = input_option_new(input_options, "name",
+	    WSCONS_KBD_DEVICE);
+	input_options = input_option_new(input_options, "driver", "kbd");
+
+	config_info = Xprintf("wscons:%s", WSCONS_KBD_DEVICE);
+	if (!config_info)
+		goto unwind;
+	if (KB_ENCODING(wsenc) == KB_USER) {
+		/* Ignore wscons "user" layout */
+		LogMessageVerb(X_INFO, 3, "wskbd: ignoring \"user\" layout\n");
+		goto kbd_config_done;
+	}
+	for  (i = 0; kbdenc[i].val; i++)
+		if(KB_ENCODING(wsenc) == kbdenc[i].val) {
+			LogMessageVerb(X_INFO, 3, "wskbd: using layout %s\n",
+			    kbdenc[i].name);
+			input_options = input_option_new(input_options,
+			    "xkb_layout", kbdenc[i].name);
+			break;
+		}
+	for (i = 0; kbdvar[i].val; i++)
+		if (wsenc == kbdvar[i].val ||
+		    KB_VARIANT(wsenc) == kbdvar[i].val) {
+			LogMessageVerb(X_INFO, 3, "wskbd: using variant %s\n",
+			    kbdvar[i].name);
+			input_options = input_option_new(input_options,
+			    "xkb_variant", kbdvar[i].name);
+			break;
+		}
+	for (i = 0; kbdopt[i].val; i++)
+		if (KB_VARIANT(wsenc) == kbdopt[i].val) {
+			LogMessageVerb(X_INFO, 3, "wskbd: using option %s\n",
+			    kbdopt[i].name);
+			input_options = input_option_new(input_options,
+			    "xkb_options", kbdopt[i].name);
+			break;
+		}
+	for (i = 0; kbdmodel[i].val; i++)
+		if (type == kbdmodel[i].val) {
+			LogMessageVerb(X_INFO, 3, "wskbd: using model %s\n",
+			    kbdmodel[i].name);
+			input_options = input_option_new(input_options,
+			    "xkb_model", kbdmodel[i].name);
+			break;
+		}
+
+kbd_config_done:
+	attrs.flags |= ATTR_KEYBOARD;
+	rc = NewInputDeviceRequest(input_options, &attrs, &dev);
+	if (rc != Success)
+		goto unwind;
+
+	for (; dev; dev = dev->next) {
+		free(dev->config_info);
+		dev->config_info = strdup(config_info);
+	}
+unwind:
+	input_option_free_list(&input_options);
+}
+
+static void
+wscons_add_pointer(const char *path, const char *driver, int flags)
+{
+	InputAttributes attrs = {};
+	DeviceIntPtr dev = NULL;
+	InputOption *input_options = NULL;
+	char *config_info = NULL;
+	int rc;
+
+	config_info = Xprintf("wscons:%s", path);
+	if (!config_info)
+		return;
+
+	input_options = input_option_new(input_options, "_source",
+	    "server/wscons");
+	if (input_options == NULL)
+		return;
+
+	input_options = input_option_new(input_options, "name",
+	    strdup(path));
+	input_options = input_option_new(input_options, "driver",
+	    strdup(driver));
+	input_options = input_option_new(input_options, "device",
+	    strdup(path));
+	LogMessage(X_INFO, "config/wscons: checking input device %s\n", path);
+	attrs.flags |= flags;
+	rc = NewInputDeviceRequest(input_options, &attrs, &dev);
+	if (rc != Success)
+		goto unwind;
+
+	for (; dev; dev = dev->next) {
+		free(dev->config_info);
+		dev->config_info = strdup(config_info);
+	}
+unwind:
+	input_option_free_list(&input_options);
+}
+
+static void
+wscons_add_pointers(void)
+{
+	char devname[256];
+	int fd, i, wsmouse_type;
+
+	/* Check pointing devices */
+	for (i = 0; i < 4; i++) {
+		snprintf(devname, sizeof(devname), "%s%d",
+		    WSCONS_MOUSE_PREFIX, i);
+		LogMessageVerb(X_INFO, 10, "wsmouse: checking %s\n", devname);
+		fd = open_device(devnamem O_RDWR | O_NONBLOCK | O_EXCL);
+		if (fd == -1) {
+			LogMessageVerb(X_WARNING, 10, "%s: %s\n", devname,
+			    strerror(errno));
+			continue;
+		}
+		if (ioctl(fd, WSMOUSEIO_GTYPE, &wsmouse_type) != 0) {
+			LogMessageVerb(X_WARNING, 10,
+			    "%s: WSMOUSEIO_GTYPE failed\n", devname);
+			close(fd);
+			continue;
+		}
+		close(fd);
+		switch (wsmouse_type) {
+		case WSMOUSE_TYPE_SYNAPTICS:
+			wscons_add_pointer(devname, "synaptics",
+			    ATTR_TOUCHPAD);
+			break;
+		case WSMOUSE_TYPE_TPANEL:
+			wscons_add_pointer(devname, "ws", ATTR_TOUCHSCREEN);
+			break;
+		default:
+			break;
+		}
+	}
+	/* Add a default entry catching all other mux elements as "mouse" */
+	wscons_add_pointer(WSCONS_MOUSE_PREFIX, "mouse", ATTR_POINTER);
+}
+
+int
+config_wscons_init(void)
+{
+	wscons_add_keyboard();
+	wscons_add_pointers();
+	return 1;
+}
+
+void
+config_wscons_fini(void)
+{
+	/* Not much to do ? */
+}
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index b0d26435a..67a683620 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -629,6 +629,7 @@ AC_ARG_ENABLE(dpms,           AS_HELP_STRING([--disable-dpms], [Build DPMS exten
 AC_ARG_ENABLE(config-udev,    AS_HELP_STRING([--enable-config-udev], [Build udev support (default: auto)]), [CONFIG_UDEV=$enableval], [CONFIG_UDEV=auto])
 AC_ARG_ENABLE(config-dbus,    AS_HELP_STRING([--enable-config-dbus], [Build D-BUS API support (default: no)]), [CONFIG_DBUS_API=$enableval], [CONFIG_DBUS_API=no])
 AC_ARG_ENABLE(config-hal,     AS_HELP_STRING([--disable-config-hal], [Build HAL support (default: auto)]), [CONFIG_HAL=$enableval], [CONFIG_HAL=auto])
+AC_ARG_ENABLE(config-wscons,  AS_HELP_STRING([--enable-config-wscons], [Build wscons config support (default: auto)]), [CONFIG_WSCONS=$enableval], [CONFIG_WSCONS=auto])
 AC_ARG_ENABLE(xfree86-utils,     AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
 AC_ARG_ENABLE(xaa,               AS_HELP_STRING([--enable-xaa], [Build XAA (default: enabled)]), [XAA=$enableval], [XAA=yes])
 AC_ARG_ENABLE(vgahw,          AS_HELP_STRING([--enable-vgahw], [Build Xorg with vga access (default: enabled)]), [VGAHW=$enableval], [VGAHW=yes])
@@ -723,7 +724,7 @@ case $host_os in
 			AC_CACHE_CHECK([whether to build Xquartz],xorg_cv_Carbon_framework,[
 		 		save_LDFLAGS=$LDFLAGS
 				LDFLAGS="$LDFLAGS -framework Carbon"
-				AC_LINK_IFELSE([char FSFindFolder(); int main() { FSFindFolder(); return 0;}],
+				AC_LINK_IFELSE([AC_LANG_SOURCE([char FSFindFolder(); int main() { FSFindFolder(); return 0;}])],
 				               [xorg_cv_Carbon_framework=yes],
 				               [xorg_cv_Carbon_framework=no])
 			        LDFLAGS=$save_LDFLAGS])
@@ -778,7 +779,7 @@ WINDOWSWMPROTO="windowswmproto"
 APPLEWMPROTO="applewmproto >= 1.4"
 
 dnl Core modules for most extensions, et al.
-SDK_REQUIRED_MODULES="[xproto >= 7.0.22] [randrproto >= 1.2.99.3] [renderproto >= 0.11] [xextproto >= 7.1.99] [inputproto >= 1.9.99.902] [kbproto >= 1.0.3] fontsproto"
+SDK_REQUIRED_MODULES="[xproto >= 7.0.22] [randrproto >= 1.2.99.3] [renderproto >= 0.11] [xextproto >= 7.1.99] [inputproto >= 2.0.99.1] [kbproto >= 1.0.3] fontsproto"
 # Make SDK_REQUIRED_MODULES available for inclusion in xorg-server.pc
 AC_SUBST(SDK_REQUIRED_MODULES)
 
@@ -822,6 +823,15 @@ if test "x$CONFIG_UDEV" = xyes; then
 		AC_MSG_ERROR([udev configuration API requested, but libudev is not installed])
 	fi
 	AC_DEFINE(CONFIG_UDEV, 1, [Use libudev for input hotplug])
+
+	SAVE_LIBS=$LIBS
+	SAVE_CFLAGS=$CFLAGS
+	CFLAGS=$UDEV_CFLAGS
+	LIBS=$UDEV_LIBS
+	AC_CHECK_FUNCS([udev_monitor_filter_add_match_tag])
+	AC_CHECK_FUNCS([udev_enumerate_add_match_tag])
+	LIBS=$SAVE_LIBS
+	CFLAGS=$SAVE_CFLAGS
 fi
 
 dnl HAVE_DBUS is true if we actually have the D-Bus library, whereas
@@ -865,6 +875,21 @@ if test "x$CONFIG_NEED_DBUS" = xyes; then
 fi
 AM_CONDITIONAL(CONFIG_NEED_DBUS, [test "x$CONFIG_NEED_DBUS" = xyes])
 
+if test "x$CONFIG_WSCONS" = xauto; then
+	case $host_os in
+		*openbsd*)
+			CONFIG_WSCONS=yes;
+			;;
+		*)
+			CONFIG_WSCONS=no;
+			;;
+	esac
+fi
+AM_CONDITIONAL(CONFIG_WSCONS, [test "x$CONFIG_WSCONS" = xyes])
+if test "x$CONFIG_WSCONS" = xyes; then
+	AC_DEFINE(CONFIG_WSCONS, 1, [Use wscons for input auto configuration])
+fi
+
 if test "x$USE_SIGIO_BY_DEFAULT" = xyes; then
 	USE_SIGIO_BY_DEFAULT_VALUE=TRUE
 else
@@ -874,12 +899,12 @@ AC_DEFINE_UNQUOTED([USE_SIGIO_BY_DEFAULT], [$USE_SIGIO_BY_DEFAULT_VALUE],
 		   [Use SIGIO handlers for input device events by default])
 
 AC_MSG_CHECKING([for glibc...])
-AC_PREPROC_IFELSE([
+AC_PREPROC_IFELSE([AC_LANG_SOURCE([
 #include <features.h>
 #ifndef __GLIBC__
 #error
 #endif
-], glibc=yes, glibc=no)
+])], glibc=yes, glibc=no)
 AC_MSG_RESULT([$glibc])
 
 AC_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes],
@@ -903,7 +928,7 @@ if ! test "x$have_clock_gettime" = xno; then
         CPPFLAGS="$CPPFLAGS -D_POSIX_C_SOURCE=200112L"
     fi
 
-    AC_RUN_IFELSE([
+    AC_RUN_IFELSE([AC_LANG_SOURCE([
 #include <time.h>
 
 int main(int argc, char *argv[[]]) {
@@ -914,7 +939,7 @@ int main(int argc, char *argv[[]]) {
     else
         return 1;
 }
-    ], [MONOTONIC_CLOCK=yes], [MONOTONIC_CLOCK=no],
+    ])], [MONOTONIC_CLOCK=yes], [MONOTONIC_CLOCK=no],
        [MONOTONIC_CLOCK="cross compiling"])
 
     LIBS="$LIBS_SAVE"
diff --git a/xorg-server/dbe/dbe.c b/xorg-server/dbe/dbe.c
index 86d8220b8..a46867676 100644
--- a/xorg-server/dbe/dbe.c
+++ b/xorg-server/dbe/dbe.c
@@ -38,12 +38,7 @@
 #endif
 
 #include <string.h>
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
-
 #include <X11/X.h>
 #include <X11/Xproto.h>
 #include "scrnintstr.h"
diff --git a/xorg-server/dix/devices.c b/xorg-server/dix/devices.c
index ab8a648a9..64557aaf1 100644
--- a/xorg-server/dix/devices.c
+++ b/xorg-server/dix/devices.c
@@ -260,6 +260,8 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart)
 					  offsetof(DeviceIntRec, devPrivates), PRIVATE_DEVICE);
     if (!dev)
 	return (DeviceIntPtr)NULL;
+
+    dev->last.scroll = NULL;
     dev->id = devid;
     dev->public.processInputProc = ProcessOtherEvent;
     dev->public.realInputProc = ProcessOtherEvent;
@@ -939,6 +941,7 @@ CloseDevice(DeviceIntPtr dev)
 
     free(dev->deviceGrab.sync.event);
     free(dev->config_info);     /* Allocated in xf86ActivateDevice. */
+    free(dev->last.scroll);
     dev->config_info = NULL;
     dixFreeObjectWithPrivates(dev, PRIVATE_DEVICE);
 }
@@ -1277,10 +1280,19 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes, Atom *labels,
     if (!valc)
         return FALSE;
 
+    dev->last.scroll = valuator_mask_new(numAxes);
+    if (!dev->last.scroll)
+    {
+        free(valc);
+        return FALSE;
+    }
+
     valc->sourceid = dev->id;
     valc->motion = NULL;
     valc->first_motion = 0;
     valc->last_motion = 0;
+    valc->h_scroll_axis = -1;
+    valc->v_scroll_axis = -1;
 
     valc->numMotionEvents = numMotionEvents;
     valc->motionHintWindow = NullWindow;
diff --git a/xorg-server/dix/dixfonts.c b/xorg-server/dix/dixfonts.c
index fbac124da..d2bcb84ea 100644
--- a/xorg-server/dix/dixfonts.c
+++ b/xorg-server/dix/dixfonts.c
@@ -1302,31 +1302,30 @@ doPolyText(ClientPtr client, PTclosurePtr c)
 			goto bail;
 		    }
 		    *new_closure = *c;
-		    c = new_closure;
 
-		    len = c->endReq - c->pElt;
-		    c->data = malloc(len);
-		    if (!c->data)
+		    len = new_closure->endReq - new_closure->pElt;
+		    new_closure->data = malloc(len);
+		    if (!new_closure->data)
 		    {
-			free(c);
+			free(new_closure);
 			err = BadAlloc;
 			goto bail;
 		    }
-		    memmove(c->data, c->pElt, len);
-		    c->pElt = c->data;
-		    c->endReq = c->pElt + len;
+		    memmove(new_closure->data, new_closure->pElt, len);
+		    new_closure->pElt = new_closure->data;
+		    new_closure->endReq = new_closure->pElt + len;
 
 		    /* Step 2 */
 
-		    pGC = GetScratchGC(c->pGC->depth, c->pGC->pScreen);
+		    pGC = GetScratchGC(new_closure->pGC->depth, new_closure->pGC->pScreen);
 		    if (!pGC)
 		    {
-			free(c->data);
-			free(c);
+			free(new_closure->data);
+			free(new_closure);
 			err = BadAlloc;
 			goto bail;
 		    }
-		    if ((err = CopyGC(c->pGC, pGC, GCFunction |
+		    if ((err = CopyGC(new_closure->pGC, pGC, GCFunction |
 				      GCPlaneMask | GCForeground |
 				      GCBackground | GCFillStyle |
 				      GCTile | GCStipple |
@@ -1337,15 +1336,16 @@ doPolyText(ClientPtr client, PTclosurePtr c)
 				      Success)
 		    {
 			FreeScratchGC(pGC);
-			free(c->data);
-			free(c);
+			free(new_closure->data);
+			free(new_closure);
 			err = BadAlloc;
 			goto bail;
 		    }
+		    c = new_closure;
 		    origGC = c->pGC;
 		    c->pGC = pGC;
 		    ValidateGC(c->pDraw, c->pGC);
-		    
+
 		    ClientSleep(client, (ClientSleepProcPtr)doPolyText, c);
 
 		    /* Set up to perform steps 3 and 4 */
diff --git a/xorg-server/dix/eventconvert.c b/xorg-server/dix/eventconvert.c
index 024f2e833..f9aafa5d1 100644
--- a/xorg-server/dix/eventconvert.c
+++ b/xorg-server/dix/eventconvert.c
@@ -605,6 +605,7 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
     xde->root_x         = FP1616(ev->root_x, ev->root_x_frac);
     xde->root_y         = FP1616(ev->root_y, ev->root_y_frac);
 
+    xde->flags          = ev->flags;
     if (ev->key_repeat)
         xde->flags      |= XIKeyRepeat;
 
@@ -632,8 +633,9 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
         if (BitIsOn(ev->valuators.mask, i))
         {
             SetBit(ptr, i);
-            axisval->integral = ev->valuators.data[i];
-            axisval->frac = ev->valuators.data_frac[i];
+            axisval->integral = trunc(ev->valuators.data[i]);
+            axisval->frac = (ev->valuators.data[i] - axisval->integral) *
+                            (1 << 16) * (1 << 16);
             axisval++;
         }
     }
@@ -648,7 +650,7 @@ eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
     int vallen, nvals;
     int i, len = sizeof(xXIRawEvent);
     char *ptr;
-    FP3232 *axisval;
+    FP3232 *axisval, *axisval_raw;
 
     nvals = count_bits(ev->valuators.mask, sizeof(ev->valuators.mask));
     len += nvals * sizeof(FP3232) * 2; /* 8 byte per valuator, once
@@ -666,19 +668,25 @@ eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
     raw->detail         = ev->detail.button;
     raw->deviceid       = ev->deviceid;
     raw->valuators_len  = vallen;
+    raw->flags          = ev->flags;
 
     ptr = (char*)&raw[1];
     axisval = (FP3232*)(ptr + raw->valuators_len * 4);
+    axisval_raw = axisval + nvals;
     for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++)
     {
         if (BitIsOn(ev->valuators.mask, i))
         {
             SetBit(ptr, i);
-            axisval->integral = ev->valuators.data[i];
-            axisval->frac = ev->valuators.data_frac[i];
-            (axisval + nvals)->integral = ev->valuators.data_raw[i];
-            (axisval + nvals)->frac = ev->valuators.data_raw_frac[i];
+            axisval->integral = trunc(ev->valuators.data[i]);
+            axisval->frac = (ev->valuators.data[i] - axisval->integral) *
+                            (1 << 16) * (1 << 16);
+            axisval_raw->integral = trunc(ev->valuators.data_raw[i]);
+            axisval_raw->frac =
+                (ev->valuators.data_raw[i] - axisval_raw->integral) *
+                  (1 << 16) * (1 << 16);
             axisval++;
+            axisval_raw++;
         }
     }
 
diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c
index fbe4fc953..4e21c2df2 100644
--- a/xorg-server/dix/events.c
+++ b/xorg-server/dix/events.c
@@ -2268,33 +2268,93 @@ DeliverEventsToWindow(DeviceIntPtr pDev, WindowPtr pWin, xEvent
     return nondeliveries;
 }
 
+/**
+ * Filter out raw events for XI 2.0 and XI 2.1 clients.
+ *
+ * If there is a grab on the device, 2.0 clients only get raw events if they
+ * have the grab. 2.1+ clients get raw events in all cases.
+ *
+ * @return TRUE if the event should be discarded, FALSE otherwise.
+ */
+static BOOL
+FilterRawEvents(const ClientPtr client, const GrabPtr grab)
+{
+    XIClientPtr client_xi_version;
+    int cmp;
+
+    /* device not grabbed -> don't filter */
+    if (!grab)
+        return FALSE;
+
+    client_xi_version = dixLookupPrivate(&client->devPrivates, XIClientPrivateKey);
+
+    cmp = version_compare(client_xi_version->major_version,
+                          client_xi_version->minor_version, 2, 0);
+    /* XI 2.0: if device is grabbed, skip
+       XI 2.1: if device is grabbed by us, skip, we've already delivered */
+    return (cmp == 0) ? TRUE : SameClient(grab, client);
+}
+
+/**
+ * Deliver a raw event to the grab owner (if any) and to all root windows.
+ *
+ * Raw event delivery differs between XI 2.0 and XI 2.1.
+ * XI 2.0: events delivered to the grabbing client (if any) OR to all root
+ * windows
+ * XI 2.1: events delivered to all root windows, regardless of grabbing
+ * state.
+ */
 void
 DeliverRawEvent(RawDeviceEvent *ev, DeviceIntPtr device)
 {
     GrabPtr grab = device->deviceGrab.grab;
+    xEvent *xi;
+    int i, rc;
+    int filter;
+
+    rc = EventToXI2((InternalEvent*)ev, (xEvent**)&xi);
+    if (rc != Success)
+    {
+        ErrorF("[Xi] %s: XI2 conversion failed in %s (%d)\n",
+                __func__, device->name, rc);
+        return;
+    }
 
     if (grab)
         DeliverGrabbedEvent((InternalEvent*)ev, device, FALSE);
-    else { /* deliver to all root windows */
-        xEvent *xi;
-        int i;
-        int filter;
 
-        i = EventToXI2((InternalEvent*)ev, (xEvent**)&xi);
-        if (i != Success)
-        {
-            ErrorF("[Xi] %s: XI2 conversion failed in %s (%d)\n",
-                    __func__, device->name, i);
-            return;
-        }
+    filter = GetEventFilter(device, xi);
+
+    for (i = 0; i < screenInfo.numScreens; i++)
+    {
+        WindowPtr root;
+        InputClients *inputclients;
 
-        filter = GetEventFilter(device, xi);
+        root = screenInfo.screens[i]->root;
+        if (!GetClientsForDelivery(device, root, xi, filter, &inputclients))
+            continue;
 
-        for (i = 0; i < screenInfo.numScreens; i++)
-            DeliverEventsToWindow(device, screenInfo.screens[i]->root, xi, 1,
-                                  filter, NullGrab);
-        free(xi);
+        for (; inputclients; inputclients = inputclients->next)
+        {
+            ClientPtr c; /* unused */
+            Mask m;      /* unused */
+            InputClients ic = *inputclients;
+
+            /* Because we run through the list manually, copy the actual
+             * list, shorten the copy to only have one client and then pass
+             * that down to DeliverEventToInputClients. This way we avoid
+             * double events on XI 2.1 clients that have a grab on the
+             * device.
+             */
+            ic.next = NULL;
+
+            if (!FilterRawEvents(rClient(&ic), grab))
+                DeliverEventToInputClients(device, &ic, root, xi, 1,
+                                           filter, NULL, &c, &m);
+        }
     }
+
+    free(xi);
 }
 
 /* If the event goes to dontClient, don't send it and return 0.  if
diff --git a/xorg-server/dix/getevents.c b/xorg-server/dix/getevents.c
index be2840c47..c42971592 100644
--- a/xorg-server/dix/getevents.c
+++ b/xorg-server/dix/getevents.c
@@ -2,6 +2,7 @@
  * Copyright © 2006 Nokia Corporation
  * Copyright © 2006-2007 Daniel Stone
  * Copyright © 2008 Red Hat, Inc.
+ * Copyright © 2011 The Chromium Authors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -58,6 +59,7 @@
 #endif
 
 #include <X11/extensions/XI.h>
+#include <X11/extensions/XI2.h>
 #include <X11/extensions/XIproto.h>
 #include <pixman.h>
 #include "exglobals.h"
@@ -167,7 +169,7 @@ init_raw(DeviceIntPtr dev, RawDeviceEvent *event, Time ms, int type, int detail)
 }
 
 static void
-set_raw_valuators(RawDeviceEvent *event, ValuatorMask *mask, int32_t* data)
+set_raw_valuators(RawDeviceEvent *event, ValuatorMask *mask, double* data)
 {
     int i;
 
@@ -176,7 +178,7 @@ set_raw_valuators(RawDeviceEvent *event, ValuatorMask *mask, int32_t* data)
         if (valuator_mask_isset(mask, i))
         {
             SetBit(event->valuators.mask, i);
-            data[i] = valuator_mask_get(mask, i);
+            data[i] = valuator_mask_get_double(mask, i);
         }
     }
 }
@@ -196,9 +198,7 @@ set_valuators(DeviceIntPtr dev, DeviceEvent* event, ValuatorMask *mask)
             SetBit(event->valuators.mask, i);
             if (valuator_get_mode(dev, i) == Absolute)
                 SetBit(event->valuators.mode, i);
-            event->valuators.data[i] = valuator_mask_get(mask, i);
-            event->valuators.data_frac[i] =
-                dev->last.remainder[i] * (1 << 16) * (1 << 16);
+            event->valuators.data[i] = valuator_mask_get_double(mask, i);
         }
         else if (valuator_get_mode(dev, i) == Absolute)
             event->valuators.data[i] = dev->valuator->axisVal[i];
@@ -255,39 +255,29 @@ CreateClassesChangedEvent(InternalEvent* event,
 /**
  * Rescale the coord between the two axis ranges.
  */
-static int
-rescaleValuatorAxis(int coord, float remainder, float *remainder_return, AxisInfoPtr from, AxisInfoPtr to,
-                    int defmax)
+static double
+rescaleValuatorAxis(double coord, AxisInfoPtr from, AxisInfoPtr to,
+                    double defmax)
 {
-    int fmin = 0, tmin = 0, fmax = defmax, tmax = defmax, coord_return;
-    float value;
+    double fmin = 0.0, fmax = defmax;
+    double tmin = 0.0, tmax = defmax;
 
-    if(from && from->min_value < from->max_value) {
+    if (from && from->min_value < from->max_value) {
         fmin = from->min_value;
         fmax = from->max_value;
     }
-    if(to && to->min_value < to->max_value) {
+    if (to && to->min_value < to->max_value) {
         tmin = to->min_value;
         tmax = to->max_value;
     }
 
-    if(fmin == tmin && fmax == tmax) {
-        if (remainder_return)
-            *remainder_return = remainder;
+    if (fmin == tmin && fmax == tmax)
         return coord;
-    }
 
-    if(fmax == fmin) { /* avoid division by 0 */
-        if (remainder_return)
-            *remainder_return = 0.0;
-        return 0;
-    }
+    if (fmax == fmin) /* avoid division by 0 */
+        return 0.0;
 
-    value = (coord + remainder - fmin) * (tmax - tmin) / (fmax - fmin) + tmin;
-    coord_return = lroundf(value);
-    if (remainder_return)
-        *remainder_return = value - coord_return;
-    return coord_return;
+    return (coord - fmin) * (tmax - tmin) / (fmax - fmin) + tmin;
 }
 
 /**
@@ -309,19 +299,25 @@ updateSlaveDeviceCoords(DeviceIntPtr master, DeviceIntPtr pDev)
      * position of the pointer */
     pDev->last.valuators[0] = master->last.valuators[0];
     pDev->last.valuators[1] = master->last.valuators[1];
-    pDev->last.remainder[0] = master->last.remainder[0];
-    pDev->last.remainder[1] = master->last.remainder[1];
 
     if (!pDev->valuator)
         return;
 
     /* scale back to device coordinates */
     if(pDev->valuator->numAxes > 0)
-        pDev->last.valuators[0] = rescaleValuatorAxis(pDev->last.valuators[0], pDev->last.remainder[0],
-                        &pDev->last.remainder[0], NULL, pDev->valuator->axes + 0, scr->width);
+    {
+        pDev->last.valuators[0] = rescaleValuatorAxis(pDev->last.valuators[0],
+                                                      NULL,
+                                                      pDev->valuator->axes + 0,
+                                                      scr->width);
+    }
     if(pDev->valuator->numAxes > 1)
-        pDev->last.valuators[1] = rescaleValuatorAxis(pDev->last.valuators[1], pDev->last.remainder[1],
-                        &pDev->last.remainder[1], NULL, pDev->valuator->axes + 1, scr->height);
+    {
+        pDev->last.valuators[1] = rescaleValuatorAxis(pDev->last.valuators[1],
+                                                      NULL,
+                                                      pDev->valuator->axes + 1,
+                                                      scr->height);
+    }
 
     /* calculate the other axis as well based on info from the old
      * slave-device. If the old slave had less axes than this one,
@@ -332,16 +328,13 @@ updateSlaveDeviceCoords(DeviceIntPtr master, DeviceIntPtr pDev)
             if (i >= lastSlave->valuator->numAxes)
             {
                 pDev->last.valuators[i] = 0;
-                pDev->last.remainder[i] = 0;
             }
             else
             {
-                pDev->last.valuators[i] =
-                    rescaleValuatorAxis(pDev->last.valuators[i],
-                            pDev->last.remainder[i],
-                            &pDev->last.remainder[i],
-                            lastSlave->valuator->axes + i,
-                            pDev->valuator->axes + i, 0);
+                double val = pDev->last.valuators[i];
+                val = rescaleValuatorAxis(val, lastSlave->valuator->axes + i,
+                                          pDev->valuator->axes + i, 0);
+                pDev->last.valuators[i] = val;
             }
         }
     }
@@ -452,7 +445,7 @@ GetMotionHistory(DeviceIntPtr pDev, xTimecoord **buff, unsigned long start,
                 /* scale to screen coords */
                 to = &core_axis;
                 to->max_value = pScreen->width;
-                coord = rescaleValuatorAxis(coord, 0.0, NULL, &from, to, pScreen->width);
+                coord = rescaleValuatorAxis(coord, &from, to, pScreen->width);
 
                 memcpy(corebuf, &coord, sizeof(INT16));
                 corebuf++;
@@ -463,7 +456,7 @@ GetMotionHistory(DeviceIntPtr pDev, xTimecoord **buff, unsigned long start,
                 memcpy(&coord, icbuf++, sizeof(INT32));
 
                 to->max_value = pScreen->height;
-                coord = rescaleValuatorAxis(coord, 0.0, NULL, &from, to, pScreen->height);
+                coord = rescaleValuatorAxis(coord, &from, to, pScreen->height);
                 memcpy(corebuf, &coord, sizeof(INT16));
 
             } else if (IsMaster(pDev))
@@ -491,7 +484,7 @@ GetMotionHistory(DeviceIntPtr pDev, xTimecoord **buff, unsigned long start,
                         from.max_value = pScreen->height;
 
                     /* scale from stored range into current range */
-                    coord = rescaleValuatorAxis(coord, 0.0, NULL, &from, to, 0);
+                    coord = rescaleValuatorAxis(coord, &from, to, 0);
                     memcpy(ocbuf, &coord, sizeof(INT32));
                     ocbuf++;
                 }
@@ -525,7 +518,7 @@ GetMotionHistory(DeviceIntPtr pDev, xTimecoord **buff, unsigned long start,
  */
 static void
 updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
-                    int *valuators)
+                    double *valuators)
 {
     char *buff = (char *) pDev->valuator->motion;
     ValuatorClassPtr v;
@@ -547,6 +540,7 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
 
         for (i = 0; i < v->numAxes; i++)
         {
+            int val;
             /* XI1 doesn't support mixed mode devices */
             if (valuator_get_mode(pDev, i) != valuator_get_mode(pDev, 0))
                 break;
@@ -559,7 +553,8 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
             buff += sizeof(INT32);
             memcpy(buff, &v->axes[i].max_value, sizeof(INT32));
             buff += sizeof(INT32);
-            memcpy(buff, &valuators[i], sizeof(INT32));
+            val = valuators[i];
+            memcpy(buff, &val, sizeof(INT32));
             buff += sizeof(INT32);
         }
     } else
@@ -575,12 +570,14 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
 
         for (i = 0; i < MAX_VALUATORS; i++)
         {
+            int val;
             if (valuator_mask_size(mask) <= i || !valuator_mask_isset(mask, i))
             {
                 buff += sizeof(INT32);
                 continue;
             }
-            memcpy(buff, &valuators[i], sizeof(INT32));
+            val = valuators[i];
+            memcpy(buff, &val, sizeof(INT32));
             buff += sizeof(INT32);
         }
     }
@@ -607,8 +604,10 @@ GetMaximumEventsNum(void) {
     /* One raw event
      * One device event
      * One possible device changed event
+     * Lots of possible separate button scroll events (horiz + vert)
+     * Lots of possible separate raw button scroll events (horiz + vert)
      */
-    return 3;
+    return 100;
 }
 
 
@@ -617,7 +616,7 @@ GetMaximumEventsNum(void) {
  * InitValuatorAxisClassStruct.
  */
 static void
-clipAxis(DeviceIntPtr pDev, int axisNum, int *val)
+clipAxis(DeviceIntPtr pDev, int axisNum, double *val)
 {
     AxisInfoPtr axis;
 
@@ -647,9 +646,9 @@ clipValuators(DeviceIntPtr pDev, ValuatorMask *mask)
     for (i = 0; i < valuator_mask_size(mask); i++)
         if (valuator_mask_isset(mask, i))
         {
-            int val = valuator_mask_get(mask, i);
+            double val = valuator_mask_get_double(mask, i);
             clipAxis(pDev, i, &val);
-            valuator_mask_set(mask, i, val);
+            valuator_mask_set_double(mask, i, val);
         }
 }
 
@@ -690,85 +689,52 @@ UpdateFromMaster(InternalEvent* events, DeviceIntPtr dev, int type, int *num_eve
 /**
  * Move the device's pointer to the position given in the valuators.
  *
- * @param dev The device which's pointer is to be moved.
- * @param x Returns the x position of the pointer after the move.
- * @param y Returns the y position of the pointer after the move.
- * @param mask Bit mask of valid valuators.
- * @param valuators Valuator data for each axis between @first and
- *        @first+@num.
+ * @param dev The device whose pointer is to be moved.
+ * @param mask Valuator data for this event.
  */
 static void
-moveAbsolute(DeviceIntPtr dev, int *x, int *y, ValuatorMask *mask)
+moveAbsolute(DeviceIntPtr dev, ValuatorMask *mask)
 {
     int i;
 
-    if (valuator_mask_isset(mask, 0))
-        *x = valuator_mask_get(mask, 0);
-    else
-        *x = dev->last.valuators[0];
-
-    if (valuator_mask_isset(mask, 1))
-        *y = valuator_mask_get(mask, 1);
-    else
-        *y = dev->last.valuators[1];
-
-    clipAxis(dev, 0, x);
-    clipAxis(dev, 1, y);
-
-    for (i = 2; i < valuator_mask_size(mask); i++)
+    for (i = 0; i < valuator_mask_size(mask); i++)
     {
-        if (valuator_mask_isset(mask, i))
-        {
-            dev->last.valuators[i] = valuator_mask_get(mask, i);
-            clipAxis(dev, i, &dev->last.valuators[i]);
-        }
+        double val;
+
+        if (!valuator_mask_isset(mask, i))
+            continue;
+        val = valuator_mask_get_double(mask, i);
+        clipAxis(dev, i, &val);
+        valuator_mask_set_double(mask, i, val);
     }
 }
 
 /**
  * Move the device's pointer by the values given in @valuators.
  *
- * @param dev The device which's pointer is to be moved.
- * @param x Returns the x position of the pointer after the move.
- * @param y Returns the y position of the pointer after the move.
- * @param mask Bit mask of valid valuators.
- * @param valuators Valuator data for each axis between @first and
- *        @first+@num.
+ * @param dev The device whose pointer is to be moved.
+ * @param mask Valuator data for this event.
  */
 static void
-moveRelative(DeviceIntPtr dev, int *x, int *y, ValuatorMask *mask)
+moveRelative(DeviceIntPtr dev, ValuatorMask *mask)
 {
     int i;
-
-    *x = dev->last.valuators[0];
-    *y = dev->last.valuators[1];
-
-    if (valuator_mask_isset(mask, 0))
-        *x += valuator_mask_get(mask, 0);
-
-    if (valuator_mask_isset(mask, 1))
-        *y += valuator_mask_get(mask, 1);
-
-    /* if attached, clip both x and y to the defined limits (usually
-     * co-ord space limit). If it is attached, we need x/y to go over the
-     * limits to be able to change screens. */
-    if (dev->valuator && (IsMaster(dev) || !IsFloating(dev))) {
-        if (valuator_get_mode(dev, 0) == Absolute)
-            clipAxis(dev, 0, x);
-        if (valuator_get_mode(dev, 1) == Absolute)
-            clipAxis(dev, 1, y);
-    }
+    Bool clip_xy = IsMaster(dev) || !IsFloating(dev);
 
     /* calc other axes, clip, drop back into valuators */
-    for (i = 2; i < valuator_mask_size(mask); i++)
+    for (i = 0; i < valuator_mask_size(mask); i++)
     {
-        if (valuator_mask_isset(mask, i))
-        {
-            dev->last.valuators[i] += valuator_mask_get(mask, i);
-            if (valuator_get_mode(dev, i) == Absolute)
-                clipAxis(dev, i, &dev->last.valuators[i]);
-            valuator_mask_set(mask, i, dev->last.valuators[i]);
-        }
+        double val = dev->last.valuators[i];
+
+        if (!valuator_mask_isset(mask, i))
+            continue;
+        val += valuator_mask_get_double(mask, i);
+        /* x & y need to go over the limits to cross screens if the SD
+         * isn't currently attached; otherwise, clip to screen bounds. */
+        if (valuator_get_mode(dev, i) == Absolute &&
+            ((i != 0 && i != 1) || clip_xy))
+            clipAxis(dev, i, &val);
+        valuator_mask_set_double(mask, i, val);
     }
 }
 
@@ -799,89 +765,68 @@ accelPointer(DeviceIntPtr dev, ValuatorMask* valuators, CARD32 ms)
  *
  * @param dev The device to be moved.
  * @param mode Movement mode (Absolute or Relative)
- * @param x Pointer to current x-axis value, may be modified.
- * @param y Pointer to current y-axis value, may be modified.
- * @param x_frac Fractional part of current x-axis value, may be modified.
- * @param y_frac Fractional part of current y-axis value, may be modified.
  * @param scr Screen the device's sprite is currently on.
+ * @param mask Mask of axis values for this event
  * @param screenx Screen x coordinate the sprite is on after the update.
  * @param screeny Screen y coordinate the sprite is on after the update.
- * @param screenx_frac Fractional part of screen x coordinate, as above.
- * @param screeny_frac Fractional part of screen y coordinate, as above.
  */
 static void
-positionSprite(DeviceIntPtr dev, int mode,
-               int *x, int *y, float x_frac, float y_frac,
-               ScreenPtr scr, int *screenx, int *screeny, float *screenx_frac, float *screeny_frac)
+positionSprite(DeviceIntPtr dev, int mode, ScreenPtr scr, ValuatorMask *mask,
+               double *screenx, double *screeny)
 {
-    int old_screenx, old_screeny;
+    int isx, isy; /* screen {x, y}, in int */
+    double x, y;
 
-    /* scale x&y to screen */
-    if (dev->valuator && dev->valuator->numAxes > 0) {
-        *screenx = rescaleValuatorAxis(*x, x_frac, screenx_frac,
-                dev->valuator->axes + 0, NULL, scr->width);
-    } else {
-        *screenx = dev->last.valuators[0];
-        *screenx_frac = dev->last.remainder[0];
-    }
+    if (!dev->valuator || dev->valuator->numAxes < 2)
+        return;
 
-    if (dev->valuator && dev->valuator->numAxes > 1) {
-        *screeny = rescaleValuatorAxis(*y, y_frac, screeny_frac,
-                dev->valuator->axes + 1, NULL, scr->height);
-    } else {
-        *screeny = dev->last.valuators[1];
-        *screeny_frac = dev->last.remainder[1];
-    }
+    if (valuator_mask_isset(mask, 0))
+        x = valuator_mask_get_double(mask, 0);
+    else
+        x = dev->last.valuators[0];
+    if (valuator_mask_isset(mask, 1))
+        y = valuator_mask_get_double(mask, 1);
+    else
+        y = dev->last.valuators[1];
 
-    /* Hit the left screen edge? */
-    if (*screenx <= 0 && *screenx_frac < 0.0f)
+    /* scale x&y to screen */
+    *screenx = rescaleValuatorAxis(x, dev->valuator->axes + 0, NULL,
+                                   scr->width);
+    *screeny = rescaleValuatorAxis(y, dev->valuator->axes + 1, NULL,
+                                   scr->height);
+
+    /* miPointerSetPosition takes care of crossing screens for us, as well as
+     * clipping to the current screen.  In the event we actually change screen,
+     * we just drop the float component on the floor, then convert from
+     * screenx back into device co-ordinates. */
+    isx = trunc(*screenx);
+    isy = trunc(*screeny);
+    miPointerSetPosition(dev, mode, &isx, &isy);
+    scr = miPointerGetScreen(dev);
+    if (isx != trunc(*screenx))
     {
-        *screenx_frac = 0.0f;
-        x_frac = 0.0f;
+        *screenx -= trunc(*screenx) - isx;
+        x = rescaleValuatorAxis(*screenx, NULL, dev->valuator->axes + 0,
+                                scr->width);
     }
-    if (*screeny <= 0 && *screeny_frac < 0.0f)
+    if (isy != trunc(*screeny))
     {
-        *screeny_frac = 0.0f;
-        y_frac = 0.0f;
+        *screeny -= trunc(*screeny) - isy;
+        y = rescaleValuatorAxis(*screeny, NULL, dev->valuator->axes + 1,
+                                scr->height);
     }
 
-
-    old_screenx = *screenx;
-    old_screeny = *screeny;
-    /* This takes care of crossing screens for us, as well as clipping
-     * to the current screen. */
-    miPointerSetPosition(dev, mode, screenx, screeny);
-
-    if(!IsMaster(dev) && !IsFloating(dev)) {
+    /* Update the MD's co-ordinates, which are always in screen space. */
+    if (!IsMaster(dev) || !IsFloating(dev)) {
         DeviceIntPtr master = GetMaster(dev, MASTER_POINTER);
         master->last.valuators[0] = *screenx;
         master->last.valuators[1] = *screeny;
-        master->last.remainder[0] = *screenx_frac;
-        master->last.remainder[1] = *screeny_frac;
-    }
-
-    if (dev->valuator)
-    {
-        /* Crossed screen? Scale back to device coordiantes */
-        if(*screenx != old_screenx)
-        {
-            scr = miPointerGetScreen(dev);
-            *x = rescaleValuatorAxis(*screenx, *screenx_frac, &x_frac, NULL,
-                                    dev->valuator->axes + 0, scr->width);
-        }
-        if(*screeny != old_screeny)
-        {
-            scr = miPointerGetScreen(dev);
-            *y = rescaleValuatorAxis(*screeny, *screeny_frac, &y_frac, NULL,
-                                     dev->valuator->axes + 1, scr->height);
-        }
     }
 
-    /* dropy x/y (device coordinates) back into valuators for next event */
-    dev->last.valuators[0] = *x;
-    dev->last.valuators[1] = *y;
-    dev->last.remainder[0] = x_frac;
-    dev->last.remainder[1] = y_frac;
+    if (valuator_mask_isset(mask, 0))
+        valuator_mask_set_double(mask, 0, x);
+    if (valuator_mask_isset(mask, 1))
+        valuator_mask_set_double(mask, 1, y);
 }
 
 /**
@@ -1045,32 +990,37 @@ FreeEventList(InternalEvent *list, int num_events)
  * back into x/y.
  */
 static void
-transform(struct pixman_f_transform *m, int *x, int *y)
+transform(struct pixman_f_transform *m, double *x, double *y)
 {
     struct pixman_f_vector p = {.v = {*x, *y, 1}};
     pixman_f_transform_point(m, &p);
 
-    *x = lround(p.v[0]);
-    *y = lround(p.v[1]);
+    *x = p.v[0];
+    *y = p.v[1];
 }
 
 static void
 transformAbsolute(DeviceIntPtr dev, ValuatorMask *mask)
 {
-    int x, y, ox, oy;
+    double x, y, ox, oy;
+
+    if (valuator_mask_isset(mask, 0))
+        ox = x = valuator_mask_get_double(mask, 0);
+    else
+        ox = x = dev->last.valuators[0];
 
-    ox = x = valuator_mask_isset(mask, 0) ? valuator_mask_get(mask, 0) :
-                                            dev->last.valuators[0];
-    oy = y = valuator_mask_isset(mask, 1) ? valuator_mask_get(mask, 1) :
-                                            dev->last.valuators[1];
+    if (valuator_mask_isset(mask, 1))
+        oy = y = valuator_mask_get_double(mask, 1);
+    else
+        oy = y = dev->last.valuators[1];
 
     transform(&dev->transform, &x, &y);
 
     if (valuator_mask_isset(mask, 0) || ox != x)
-        valuator_mask_set(mask, 0, x);
+        valuator_mask_set_double(mask, 0, x);
 
     if (valuator_mask_isset(mask, 1) || oy != y)
-        valuator_mask_set(mask, 1, y);
+        valuator_mask_set_double(mask, 1, y);
 }
 
 /**
@@ -1097,42 +1047,25 @@ QueuePointerEvents(DeviceIntPtr device, int type,
 }
 
 /**
- * Generate a series of InternalEvents representing pointer motion, or
- * button presses.
- *
- * The DDX is responsible for allocating the events in the first
- * place via InitEventList() and GetMaximumEventsNum(), and for freeing it.
- *
- * In the generated events rootX/Y will be in absolute screen coords and
- * the valuator information in the absolute or relative device coords.
- *
- * last.valuators[x] of the device is always in absolute device coords.
- * last.valuators[x] of the master device is in absolute screen coords.
+ * Helper function for GetPointerEvents, which only generates motion and
+ * raw motion events for the slave device: does not update the master device.
  *
- * master->last.valuators[x] for x > 2 is undefined.
+ * Should not be called by anyone other than GetPointerEvents.
  *
  * @return the number of events written into events.
  */
-int
-GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons,
-                 int flags, const ValuatorMask *mask_in) {
-    int num_events = 1;
-    CARD32 ms;
+static int
+fill_pointer_events(InternalEvent *events, DeviceIntPtr pDev, int type,
+                    int buttons, CARD32 ms, int flags,
+                    const ValuatorMask *mask_in)
+{
+    int num_events = 1, i;
     DeviceEvent *event;
-    RawDeviceEvent    *raw;
-    int x = 0, y = 0, /* device coords */
-        cx, cy; /* only screen coordinates */
-    float x_frac = 0.0, y_frac = 0.0, cx_frac, cy_frac;
+    RawDeviceEvent *raw;
+    double screenx = 0.0, screeny = 0.0;
     ScreenPtr scr = miPointerGetScreen(pDev);
     ValuatorMask mask;
 
-    /* refuse events from disabled devices */
-    if (!pDev->enabled)
-        return 0;
-
-    if (!scr)
-        return 0;
-
     switch (type)
     {
         case MotionNotify:
@@ -1148,10 +1081,6 @@ GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons
             return 0;
     }
 
-    ms = GetTimeInMillis(); /* before pointer update to help precision */
-
-    events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events);
-
     valuator_mask_copy(&mask, mask_in);
 
     if ((flags & POINTER_NORAW) == 0)
@@ -1161,61 +1090,54 @@ GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons
 	num_events++;
 
 	init_raw(pDev, raw, ms, type, buttons);
-	set_raw_valuators(raw, &mask, raw->valuators.data_raw);
+        set_raw_valuators(raw, &mask, raw->valuators.data_raw);
     }
 
     if (flags & POINTER_ABSOLUTE)
     {
         if (flags & POINTER_SCREEN) /* valuators are in screen coords */
         {
-            int scaled;
+            double scaled;
 
             if (valuator_mask_isset(&mask, 0))
             {
-                scaled = rescaleValuatorAxis(valuator_mask_get(&mask, 0),
-                                             0.0, &x_frac, NULL,
-                                             pDev->valuator->axes + 0,
+                scaled = rescaleValuatorAxis(valuator_mask_get_double(&mask, 0),
+                                             NULL, pDev->valuator->axes + 0,
                                              scr->width);
-                valuator_mask_set(&mask, 0, scaled);
+                valuator_mask_set_double(&mask, 0, scaled);
             }
             if (valuator_mask_isset(&mask, 1))
             {
-                scaled = rescaleValuatorAxis(valuator_mask_get(&mask, 1),
-                                             0.0, &y_frac, NULL,
-                                             pDev->valuator->axes + 1,
+                scaled = rescaleValuatorAxis(valuator_mask_get_double(&mask, 1),
+                                             NULL, pDev->valuator->axes + 1,
                                              scr->height);
-                valuator_mask_set(&mask, 1, scaled);
+                valuator_mask_set_double(&mask, 1, scaled);
             }
         }
 
         transformAbsolute(pDev, &mask);
-        moveAbsolute(pDev, &x, &y, &mask);
+        moveAbsolute(pDev, &mask);
     } else {
-        if (flags & POINTER_ACCELERATE) {
+        if (flags & POINTER_ACCELERATE)
             accelPointer(pDev, &mask, ms);
-            /* The pointer acceleration code modifies the fractional part
-             * in-place, so we need to extract this information first */
-            x_frac = pDev->last.remainder[0];
-            y_frac = pDev->last.remainder[1];
-        }
-        moveRelative(pDev, &x, &y, &mask);
+        moveRelative(pDev, &mask);
     }
 
     if ((flags & POINTER_NORAW) == 0)
-	set_raw_valuators(raw, &mask, raw->valuators.data);
+        set_raw_valuators(raw, &mask, raw->valuators.data);
 
-    positionSprite(pDev, (flags & POINTER_ABSOLUTE) ? Absolute : Relative,
-                   &x, &y, x_frac, y_frac, scr, &cx, &cy, &cx_frac, &cy_frac);
+    positionSprite(pDev, (flags & POINTER_ABSOLUTE) ? Absolute : Relative, scr,
+                   &mask, &screenx, &screeny);
     updateHistory(pDev, &mask, ms);
 
-    /* Update the valuators with the true value sent to the client*/
-    if (valuator_mask_isset(&mask, 0))
-        valuator_mask_set(&mask, 0, x);
-    if (valuator_mask_isset(&mask, 1))
-        valuator_mask_set(&mask, 1, y);
-
     clipValuators(pDev, &mask);
 
+    for (i = 0; i < valuator_mask_size(&mask); i++)
+    {
+        if (valuator_mask_isset(&mask, i))
+            pDev->last.valuators[i] = valuator_mask_get_double(&mask, i);
+    }
+
     event = &events->device_event;
     init_device_event(event, pDev, ms);
 
@@ -1235,10 +1157,16 @@ GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons
         event->detail.button = buttons;
     }
 
-    event->root_x = cx; /* root_x/y always in screen coords */
-    event->root_y = cy;
-    event->root_x_frac = cx_frac;
-    event->root_y_frac = cy_frac;
+    /* root_x and root_y must be in screen co-ordinates */
+    event->root_x = trunc(screenx);
+    event->root_y = trunc(screeny);
+    event->root_x_frac = screenx - trunc(screenx);
+    event->root_y_frac = screeny - trunc(screeny);
+
+    if (flags & POINTER_EMULATED) {
+        raw->flags = XIPointerEmulated;
+        event->flags = XIPointerEmulated;
+    }
 
     set_valuators(pDev, event, &mask);
 
@@ -1246,6 +1174,204 @@ GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type, int buttons
 }
 
 /**
+ * Generate events for each scroll axis that changed between before/after
+ * for the device.
+ *
+ * @param events The pointer to the event list to fill the events
+ * @param dev The device to generate the events for
+ * @param axis The axis number to generate events for
+ * @param mask State before this event in absolute coords
+ * @param[in,out] last Last scroll state posted in absolute coords (modified
+ * in-place)
+ * @param ms Current time in ms
+ * @param max_events Max number of events to be generated
+ * @return The number of events generated
+ */
+static int
+emulate_scroll_button_events(InternalEvent *events,
+                             DeviceIntPtr dev,
+                             int axis,
+                             const ValuatorMask *mask,
+                             ValuatorMask *last,
+                             CARD32 ms,
+                             int max_events)
+{
+    AxisInfoPtr ax;
+    double delta;
+    double incr;
+    int num_events = 0;
+    double total;
+    int b;
+
+    if (dev->valuator->axes[axis].scroll.type == SCROLL_TYPE_NONE)
+        return 0;
+
+    if (!valuator_mask_isset(mask, axis))
+        return 0;
+
+    ax = &dev->valuator->axes[axis];
+    incr = ax->scroll.increment;
+
+    if (!valuator_mask_isset(last, axis))
+        valuator_mask_set_double(last, axis, 0);
+
+    delta = valuator_mask_get_double(mask, axis) - valuator_mask_get_double(last, axis);
+    total = delta;
+    b = (ax->scroll.type == SCROLL_TYPE_VERTICAL) ? 5 : 7;
+
+    if ((incr > 0 && delta < 0) ||
+        (incr < 0 && delta > 0))
+        b--; /* we're scrolling up or left → button 4 or 6 */
+
+    while (fabs(delta) >= fabs(incr))
+    {
+        int nev_tmp;
+
+        if (delta > 0)
+            delta -= fabs(incr);
+        else if (delta < 0)
+            delta += fabs(incr);
+
+        /* fill_pointer_events() generates four events: one normal and one raw
+         * event for button press and button release.
+         * We may get a bigger scroll delta than we can generate events
+         * for. In that case, we keep decreasing delta, but skip events.
+         */
+        if (num_events + 4 < max_events)
+        {
+            nev_tmp = fill_pointer_events(events, dev, ButtonPress, b, ms,
+                                          POINTER_EMULATED, NULL);
+            events += nev_tmp;
+            num_events += nev_tmp;
+            nev_tmp = fill_pointer_events(events, dev, ButtonRelease, b, ms,
+                                          POINTER_EMULATED, NULL);
+            events += nev_tmp;
+            num_events += nev_tmp;
+        }
+    }
+
+    /* We emulated, update last.scroll */
+    if (total != delta)
+    {
+        total -= delta;
+        valuator_mask_set_double(last, axis,
+                                 valuator_mask_get_double(last, axis) + total);
+    }
+
+    return num_events;
+}
+
+
+/**
+ * Generate a complete series of InternalEvents (filled into the EventList)
+ * representing pointer motion, or button presses.  If the device is a slave
+ * device, also potentially generate a DeviceClassesChangedEvent to update
+ * the master device.
+ *
+ * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the event structure in the first
+ * place via InitEventList() and GetMaximumEventsNum(), and for freeing it.
+ *
+ * In the generated events rootX/Y will be in absolute screen coords and
+ * the valuator information in the absolute or relative device coords.
+ *
+ * last.valuators[x] of the device is always in absolute device coords.
+ * last.valuators[x] of the master device is in absolute screen coords.
+ *
+ * master->last.valuators[x] for x > 2 is undefined.
+ */
+int
+GetPointerEvents(InternalEvent *events, DeviceIntPtr pDev, int type,
+                 int buttons, int flags, const ValuatorMask *mask_in)
+{
+    CARD32 ms = GetTimeInMillis();
+    int num_events = 0, nev_tmp;
+    int h_scroll_axis = pDev->valuator->h_scroll_axis;
+    int v_scroll_axis = pDev->valuator->v_scroll_axis;
+    ValuatorMask mask;
+    ValuatorMask scroll;
+    int i;
+
+    /* refuse events from disabled devices */
+    if (!pDev->enabled)
+        return 0;
+
+    if (!miPointerGetScreen(pDev))
+        return 0;
+
+    events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT,
+                              &num_events);
+
+    valuator_mask_copy(&mask, mask_in);
+
+    /* Turn a scroll button press into a smooth-scrolling event if
+     * necessary. This only needs to cater for the XIScrollFlagPreferred
+     * axis (if more than one scrolling axis is present) */
+    if (type == ButtonPress)
+    {
+        double val, adj;
+        int axis;
+
+        switch (buttons) {
+        case 4:
+            adj = 1.0;
+            axis = v_scroll_axis;
+            break;
+        case 5:
+            adj = -1.0;
+            axis = v_scroll_axis;
+            break;
+        case 6:
+            adj = 1.0;
+            axis = h_scroll_axis;
+            break;
+        case 7:
+            adj = -1.0;
+            axis = h_scroll_axis;
+            break;
+        default:
+            adj = 0.0;
+            axis = -1;
+            break;
+        }
+
+        if (adj != 0.0 && axis != -1)
+        {
+            adj *= pDev->valuator->axes[axis].scroll.increment;
+            val = valuator_mask_get_double(&mask, axis) + adj;
+            valuator_mask_set_double(&mask, axis, val);
+            type = MotionNotify;
+            buttons = 0;
+        }
+    }
+
+    /* First fill out the original event set, with smooth-scrolling axes. */
+    nev_tmp = fill_pointer_events(events, pDev, type, buttons, ms, flags,
+                                  &mask);
+    events += nev_tmp;
+    num_events += nev_tmp;
+
+    valuator_mask_zero(&scroll);
+
+    /* Now turn the smooth-scrolling axes back into emulated button presses
+     * for legacy clients, based on the integer delta between before and now */
+    for (i = 0; i < valuator_mask_size(&mask); i++) {
+        if (!valuator_mask_isset(&mask, i))
+            continue;
+
+        valuator_mask_set_double(&scroll, i, pDev->last.valuators[i]);
+
+        nev_tmp = emulate_scroll_button_events(events, pDev, i, &scroll,
+                                               pDev->last.scroll, ms,
+                                               GetMaximumEventsNum() - num_events);
+        events += nev_tmp;
+        num_events += nev_tmp;
+    }
+
+    return num_events;
+}
+
+/**
  * Generate internal events representing this proximity event and enqueue
  * them on the event queue.
  *
diff --git a/xorg-server/dix/inpututils.c b/xorg-server/dix/inpututils.c
index 7aeb1e516..0a3d3d8b4 100644
--- a/xorg-server/dix/inpututils.c
+++ b/xorg-server/dix/inpututils.c
@@ -497,10 +497,10 @@ valuator_mask_isset(const ValuatorMask *mask, int valuator)
 }
 
 /**
- * Set the valuator to the given data.
+ * Set the valuator to the given floating-point data.
  */
 void
-valuator_mask_set(ValuatorMask *mask, int valuator, int data)
+valuator_mask_set_double(ValuatorMask *mask, int valuator, double data)
 {
     mask->last_bit = max(valuator, mask->last_bit);
     SetBit(mask->mask, valuator);
@@ -508,13 +508,33 @@ valuator_mask_set(ValuatorMask *mask, int valuator, int data)
 }
 
 /**
- * Return the requested valuator value. If the mask bit is not set for the
- * given valuator, the returned value is undefined.
+ * Set the valuator to the given integer data.
+ */
+void
+valuator_mask_set(ValuatorMask *mask, int valuator, int data)
+{
+    valuator_mask_set_double(mask, valuator, data);
+}
+
+/**
+ * Return the requested valuator value as a double. If the mask bit is not
+ * set for the given valuator, the returned value is undefined.
+ */
+double
+valuator_mask_get_double(const ValuatorMask *mask, int valuator)
+{
+    return mask->valuators[valuator];
+}
+
+/**
+ * Return the requested valuator value as an integer, rounding towards zero.
+ * If the mask bit is not set for the given valuator, the returned value is
+ * undefined.
  */
 int
 valuator_mask_get(const ValuatorMask *mask, int valuator)
 {
-    return mask->valuators[valuator];
+    return trunc(valuator_mask_get_double(mask, valuator));
 }
 
 /**
@@ -527,7 +547,7 @@ valuator_mask_unset(ValuatorMask *mask, int valuator)
         int i, lastbit = -1;
 
         ClearBit(mask->mask, valuator);
-        mask->valuators[valuator] = 0;
+        mask->valuators[valuator] = 0.0;
 
         for (i = 0; i <= mask->last_bit; i++)
             if (valuator_mask_isset(mask, i))
diff --git a/xorg-server/dix/ptrveloc.c b/xorg-server/dix/ptrveloc.c
index dfccf1581..53a0d0397 100644
--- a/xorg-server/dix/ptrveloc.c
+++ b/xorg-server/dix/ptrveloc.c
@@ -63,9 +63,9 @@
 /* fwds */
 int
 SetAccelerationProfile(DeviceVelocityPtr vel, int profile_num);
-static float
-SimpleSmoothProfile(DeviceIntPtr dev, DeviceVelocityPtr vel, float velocity,
-                    float threshold, float acc);
+static double
+SimpleSmoothProfile(DeviceIntPtr dev, DeviceVelocityPtr vel, double velocity,
+                    double threshold, double acc);
 static PointerAccelerationProfileFunc
 GetAccelerationProfile(DeviceVelocityPtr vel, int profile_num);
 static BOOL
@@ -478,14 +478,10 @@ DoGetDirection(int dx, int dy){
         else
             dir = UNDEFINED; /* shouldn't happen */
     } else { /* compute angle and set appropriate flags */
-        float r;
+        double r;
         int i1, i2;
 
-#ifdef _ISOC99_SOURCE
-        r = atan2f(dy, dx);
-#else
         r = atan2(dy, dx);
-#endif
         /* find direction.
          *
          * Add 360° to avoid r become negative since C has no well-defined
@@ -524,8 +520,7 @@ static int
 GetDirection(int dx, int dy){
     static int cache[DIRECTION_CACHE_SIZE][DIRECTION_CACHE_SIZE];
     int dir;
-    if (abs(dx) <= DIRECTION_CACHE_RANGE &&
-	abs(dy) <= DIRECTION_CACHE_RANGE) {
+    if (abs(dx) <= DIRECTION_CACHE_RANGE && abs(dy) <= DIRECTION_CACHE_RANGE) {
 	/* cacheable */
 	dir = cache[DIRECTION_CACHE_RANGE+dx][DIRECTION_CACHE_RANGE+dy];
 	if(dir == 0) {
@@ -553,7 +548,7 @@ GetDirection(int dx, int dy){
  * 0/0 and set it as the current one.
  */
 static inline void
-FeedTrackers(DeviceVelocityPtr vel, int dx, int dy, int cur_t)
+FeedTrackers(DeviceVelocityPtr vel, double dx, double dy, int cur_t)
 {
     int n;
     for(n = 0; n < vel->num_tracker; n++){
@@ -561,8 +556,8 @@ FeedTrackers(DeviceVelocityPtr vel, int dx, int dy, int cur_t)
 	vel->tracker[n].dy += dy;
     }
     n = (vel->cur_tracker + 1) % vel->num_tracker;
-    vel->tracker[n].dx = 0;
-    vel->tracker[n].dy = 0;
+    vel->tracker[n].dx = 0.0;
+    vel->tracker[n].dy = 0.0;
     vel->tracker[n].time = cur_t;
     vel->tracker[n].dir = GetDirection(dx, dy);
     DebugAccelF("(dix prtacc) motion [dx: %i dy: %i dir:%i diff: %i]\n",
@@ -576,9 +571,9 @@ FeedTrackers(DeviceVelocityPtr vel, int dx, int dy, int cur_t)
  * velocity scaling.
  * This assumes linear motion.
  */
-static float
+static double
 CalcTracker(const MotionTracker *tracker, int cur_t){
-    float dist = sqrt(tracker->dx * tracker->dx + tracker->dy * tracker->dy);
+    double dist = sqrt(tracker->dx * tracker->dx + tracker->dy * tracker->dy);
     int dtime = cur_t - tracker->time;
     if(dtime > 0)
 	return dist / dtime;
@@ -593,16 +588,16 @@ CalcTracker(const MotionTracker *tracker, int cur_t){
  *
  * @return The tracker's velocity or 0 if the above conditions are unmet
  */
-static float
+static double
 QueryTrackers(DeviceVelocityPtr vel, int cur_t){
     int offset, dir = UNDEFINED, used_offset = -1, age_ms;
     /* initial velocity: a low-offset, valid velocity */
-    float initial_velocity = 0, result = 0, velocity_diff;
-    float velocity_factor =  vel->corr_mul * vel->const_acceleration; /* premultiply */
+    double initial_velocity = 0, result = 0, velocity_diff;
+    double velocity_factor =  vel->corr_mul * vel->const_acceleration; /* premultiply */
     /* loop from current to older data */
     for(offset = 1; offset < vel->num_tracker; offset++){
 	MotionTracker *tracker = TRACKER(vel, offset);
-	float tracker_velocity;
+	double tracker_velocity;
 
 	age_ms = cur_t - tracker->time;
 
@@ -674,11 +669,11 @@ QueryTrackers(DeviceVelocityPtr vel, int cur_t){
 BOOL
 ProcessVelocityData2D(
     DeviceVelocityPtr vel,
-    int dx,
-    int dy,
+    double dx,
+    double dy,
     int time)
 {
-    float velocity;
+    double velocity;
 
     vel->last_velocity = vel->velocity;
 
@@ -694,12 +689,12 @@ ProcessVelocityData2D(
  * this flattens significant ( > 1) mickeys a little bit for more steady
  * constant-velocity response
  */
-static inline float
-ApplySimpleSoftening(int prev_delta, int delta)
+static inline double
+ApplySimpleSoftening(double prev_delta, double delta)
 {
-    float result = delta;
+    double result = delta;
 
-    if (delta < -1 || delta > 1) {
+    if (delta < -1.0 || delta > 1.0) {
 	if (delta > prev_delta)
 	    result -= 0.5;
 	else if (delta < prev_delta)
@@ -718,8 +713,8 @@ ApplySimpleSoftening(int prev_delta, int delta)
 static void
 ApplySoftening(
         DeviceVelocityPtr vel,
-        float* fdx,
-        float* fdy)
+        double* fdx,
+        double* fdy)
 {
     if (vel->use_softening) {
         *fdx = ApplySimpleSoftening(vel->last_dx, *fdx);
@@ -728,7 +723,7 @@ ApplySoftening(
 }
 
 static void
-ApplyConstantDeceleration(DeviceVelocityPtr vel, float *fdx, float *fdy)
+ApplyConstantDeceleration(DeviceVelocityPtr vel, double *fdx, double *fdy)
 {
     *fdx *= vel->const_acceleration;
     *fdy *= vel->const_acceleration;
@@ -737,15 +732,15 @@ ApplyConstantDeceleration(DeviceVelocityPtr vel, float *fdx, float *fdy)
 /*
  * compute the acceleration for given velocity and enforce min_acceleartion
  */
-float
+double
 BasicComputeAcceleration(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc){
+    double velocity,
+    double threshold,
+    double acc){
 
-    float result;
+    double result;
     result = vel->Profile(dev, vel, velocity, threshold, acc);
 
     /* enforce min_acceleration */
@@ -759,13 +754,13 @@ BasicComputeAcceleration(
  * If the velocity has changed, an average is taken of 6 velocity factors:
  * current velocity, last velocity and 4 times the average between the two.
  */
-static float
+static double
 ComputeAcceleration(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float threshold,
-    float acc){
-    float result;
+    double threshold,
+    double acc){
+    double result;
 
     if(vel->velocity <= 0){
 	DebugAccelF("(dix ptracc) profile skipped\n");
@@ -808,13 +803,13 @@ ComputeAcceleration(
 /**
  * Polynomial function similar previous one, but with f(1) = 1
  */
-static float
+static double
 PolynomialAccelerationProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float ignored,
-    float acc)
+    double velocity,
+    double ignored,
+    double acc)
 {
    return pow(velocity, (acc - 1.0) * 0.5);
 }
@@ -824,13 +819,13 @@ PolynomialAccelerationProfile(
  * returns acceleration for velocity.
  * This profile selects the two functions like the old scheme did
  */
-static float
+static double
 ClassicProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
     if (threshold > 0) {
 	return SimpleSmoothProfile (dev,
@@ -856,15 +851,15 @@ ClassicProfile(
  * This has the expense of overall response dependency on min-acceleration.
  * In effect, min_acceleration mimics const_acceleration in this profile.
  */
-static float
+static double
 PowerProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
-    float vel_dist;
+    double vel_dist;
 
     acc = (acc-1.0) * 0.1f + 1.0; /* without this, acc of 2 is unuseable */
 
@@ -882,11 +877,11 @@ PowerProfile(
  *  - starts faster than a sinoid
  *  - smoothness C1 (Cinf if you dare to ignore endpoints)
  */
-static inline float
-CalcPenumbralGradient(float x){
+static inline double
+CalcPenumbralGradient(double x){
     x *= 2.0f;
     x -= 1.0f;
-    return 0.5f + (x * sqrt(1.0f - x*x) + asin(x))/M_PI;
+    return 0.5f + (x * sqrt(1.0 - x*x) + asin(x))/M_PI;
 }
 
 
@@ -894,13 +889,13 @@ CalcPenumbralGradient(float x){
  * acceleration function similar to classic accelerated/unaccelerated,
  * but with smooth transition in between (and towards zero for adaptive dec.).
  */
-static float
+static double
 SimpleSmoothProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
     if(velocity < 1.0f)
         return CalcPenumbralGradient(0.5 + velocity*0.5) * 2.0f - 1.0f;
@@ -920,15 +915,15 @@ SimpleSmoothProfile(
  * This profile uses the first half of the penumbral gradient as a start
  * and then scales linearly.
  */
-static float
+static double
 SmoothLinearProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
-    float res, nv;
+    double res, nv;
 
     if(acc > 1.0f)
         acc -= 1.0f; /*this is so acc = 1 is no acceleration */
@@ -955,15 +950,15 @@ SmoothLinearProfile(
  * From 0 to threshold, the response graduates smoothly from min_accel to
  * acceleration. Beyond threshold it is exactly the specified acceleration.
  */
-static float
+static double
 SmoothLimitedProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
-    float res;
+    double res;
 
     if(velocity >= threshold || threshold == 0.0f)
 	return acc;
@@ -976,24 +971,24 @@ SmoothLimitedProfile(
 }
 
 
-static float
+static double
 LinearProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
     return acc * velocity;
 }
 
-static float
+static double
 NoProfile(
     DeviceIntPtr dev,
     DeviceVelocityPtr vel,
-    float velocity,
-    float threshold,
-    float acc)
+    double velocity,
+    double threshold,
+    double acc)
 {
     return 1.0f;
 }
@@ -1119,11 +1114,11 @@ acceleratePointerPredictable(
     ValuatorMask* val,
     CARD32 evtime)
 {
-    int dx = 0, dy = 0, tmpi;
+    double dx = 0, dy = 0;
     DeviceVelocityPtr velocitydata = GetDevicePredictableAccelData(dev);
     Bool soften = TRUE;
 
-    if (!velocitydata)
+    if (valuator_mask_num_valuators(val) == 0 || !velocitydata)
         return;
 
     if (velocitydata->statistics.profile_number == AccelProfileNone &&
@@ -1132,59 +1127,39 @@ acceleratePointerPredictable(
     }
 
     if (valuator_mask_isset(val, 0)) {
-        dx = valuator_mask_get(val, 0);
+        dx = valuator_mask_get_double(val, 0);
     }
 
     if (valuator_mask_isset(val, 1)) {
-        dy = valuator_mask_get(val, 1);
+        dy = valuator_mask_get_double(val, 1);
     }
 
-    if (dx || dy){
+    if (dx != 0.0 || dy != 0.0) {
         /* reset non-visible state? */
         if (ProcessVelocityData2D(velocitydata, dx , dy, evtime)) {
             soften = FALSE;
         }
 
         if (dev->ptrfeed && dev->ptrfeed->ctrl.num) {
-            float mult;
+            double mult;
 
             /* invoke acceleration profile to determine acceleration */
             mult = ComputeAcceleration (dev, velocitydata,
-                                        dev->ptrfeed->ctrl.threshold,
-                                        (float)dev->ptrfeed->ctrl.num /
-                                            (float)dev->ptrfeed->ctrl.den);
+					dev->ptrfeed->ctrl.threshold,
+					(double)dev->ptrfeed->ctrl.num /
+					(double)dev->ptrfeed->ctrl.den);
 
             if(mult != 1.0f || velocitydata->const_acceleration != 1.0f) {
-                float fdx = dx,
-                      fdy = dy;
-
                 if (mult > 1.0f && soften)
-                    ApplySoftening(velocitydata, &fdx, &fdy);
-                ApplyConstantDeceleration(velocitydata, &fdx, &fdy);
-
-                /* Calculate the new delta (with accel) and drop it back
-                 * into the valuator masks */
-                if (dx) {
-                    float tmp;
-                    tmp = mult * fdx + dev->last.remainder[0];
-                    /* Since it may not be apparent: lrintf() does not offer
-                     * strong statements about rounding; however because we
-                     * process each axis conditionally, there's no danger
-                     * of a toggling remainder. Its lack of guarantees likely
-                     * makes it faster on the average target. */
-                    tmpi = lrintf(tmp);
-                    valuator_mask_set(val, 0, tmpi);
-                    dev->last.remainder[0] = tmp - (float)tmpi;
-                }
-                if (dy) {
-                    float tmp;
-                    tmp = mult * fdy + dev->last.remainder[1];
-                    tmpi = lrintf(tmp);
-                    valuator_mask_set(val, 1, tmpi);
-                    dev->last.remainder[1] = tmp - (float)tmpi;
-                }
-                DebugAccelF("pos (%i | %i) remainders x: %.3f y: %.3f delta x:%.3f y:%.3f\n",
-                            *px, *py, dev->last.remainder[0], dev->last.remainder[1], fdx, fdy);
+                    ApplySoftening(velocitydata, &dx, &dy);
+                ApplyConstantDeceleration(velocitydata, &dx, &dy);
+
+                if (dx != 0.0)
+                    valuator_mask_set_double(val, 0, mult * dx);
+                if (dy != 0.0)
+                    valuator_mask_set_double(val, 1, mult * dy);
+                DebugAccelF("pos (%i | %i) delta x:%.3f y:%.3f\n", mult * dx,
+                            mult * dy);
             }
         }
     }
@@ -1205,8 +1180,8 @@ acceleratePointerLightweight(
     ValuatorMask* val,
     CARD32 ignored)
 {
-    float mult = 0.0, tmpf;
-    int dx = 0, dy = 0, tmpi;
+    double mult = 0.0, tmpf;
+    double dx = 0.0, dy = 0.0;
 
     if (valuator_mask_isset(val, 0)) {
         dx = valuator_mask_get(val, 0);
@@ -1216,53 +1191,35 @@ acceleratePointerLightweight(
         dy = valuator_mask_get(val, 1);
     }
 
-    if (!dx && !dy)
+    if (valuator_mask_num_valuators(val) == 0)
         return;
 
     if (dev->ptrfeed && dev->ptrfeed->ctrl.num) {
         /* modeled from xf86Events.c */
         if (dev->ptrfeed->ctrl.threshold) {
-            if ((abs(dx) + abs(dy)) >= dev->ptrfeed->ctrl.threshold) {
-                tmpf = ((float)dx *
-                        (float)(dev->ptrfeed->ctrl.num)) /
-                       (float)(dev->ptrfeed->ctrl.den) +
-                       dev->last.remainder[0];
-                if (dx) {
-                    tmpi = (int) tmpf;
-                    valuator_mask_set(val, 0, tmpi);
-                    dev->last.remainder[0] = tmpf - (float)tmpi;
+            if ((fabs(dx) + fabs(dy)) >= dev->ptrfeed->ctrl.threshold) {
+                if (dx != 0.0) {
+                    tmpf = (dx * (double)(dev->ptrfeed->ctrl.num)) /
+                           (double)(dev->ptrfeed->ctrl.den);
+                    valuator_mask_set_double(val, 0, tmpf);
                 }
 
-                tmpf = ((float)dy *
-                        (float)(dev->ptrfeed->ctrl.num)) /
-                       (float)(dev->ptrfeed->ctrl.den) +
-                       dev->last.remainder[1];
-                if (dy) {
-                    tmpi = (int) tmpf;
-                    valuator_mask_set(val, 1, tmpi);
-                    dev->last.remainder[1] = tmpf - (float)tmpi;
+                if (dy != 0.0) {
+                    tmpf = (dy * (double)(dev->ptrfeed->ctrl.num)) /
+                           (double)(dev->ptrfeed->ctrl.den);
+                    valuator_mask_set_double(val, 1, tmpf);
                 }
             }
         }
         else {
-            mult = pow((float)dx * (float)dx + (float)dy * (float)dy,
-                       ((float)(dev->ptrfeed->ctrl.num) /
-                        (float)(dev->ptrfeed->ctrl.den) - 1.0) /
+	    mult = pow(dx * dx + dy * dy,
+                       ((double)(dev->ptrfeed->ctrl.num) /
+                        (double)(dev->ptrfeed->ctrl.den) - 1.0) /
                        2.0) / 2.0;
-            if (dx) {
-                tmpf = mult * (float)dx +
-                       dev->last.remainder[0];
-                tmpi = (int) tmpf;
-                valuator_mask_set(val, 0, tmpi);
-                dev->last.remainder[0] = tmpf - (float)tmpi;
-            }
-            if (dy) {
-                tmpf = mult * (float)dy +
-                       dev->last.remainder[1];
-                tmpi = (int)tmpf;
-                valuator_mask_set(val, 1, tmpi);
-                dev->last.remainder[1] = tmpf - (float)tmpi;
-            }
+            if (dx != 0.0)
+                valuator_mask_set_double(val, 0, mult * dx);
+            if (dy != 0.0)
+                valuator_mask_set_double(val, 1, mult * dy);
         }
     }
 }
diff --git a/xorg-server/doc/Xinput.xml b/xorg-server/doc/Xinput.xml
index 1ae7afe7b..0a7ec8dc0 100644
--- a/xorg-server/doc/Xinput.xml
+++ b/xorg-server/doc/Xinput.xml
@@ -1,30 +1,24 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-                   "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
-
+                   "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd"[
+ <!ENTITY % defs SYSTEM "/xserver/doc/xml/xserver.ent"> %defs;
+]>
 
 <!-- lifted from troff+ms+XMan by doclifter -->
 <book id="porting">
 
 <bookinfo>
    <title>X11 Input Extension Porting Document</title>
-   <releaseinfo>X Version 11, Release 6.7</releaseinfo>
    <authorgroup>
       <author>
          <firstname>George</firstname><surname>Sachs</surname>
          <affiliation><orgname>Hewlett-Packard</orgname></affiliation>
       </author>
    </authorgroup>
-   <corpname>X Consortium Standard</corpname>
-   <copyright><year>1989</year><holder>Hewlett-Packard Company</holder></copyright>
-   <copyright><year>1990</year><holder>Hewlett-Packard Company</holder></copyright>
-   <copyright><year>1991</year><holder>Hewlett-Packard Company</holder></copyright>
-
-   <copyright><year>1989</year><holder>X Consortium</holder></copyright>
-   <copyright><year>1990</year><holder>X Consortium</holder></copyright>
-   <copyright><year>1991</year><holder>X Consortium</holder></copyright>
-   <affiliation><orgname>X Consortium</orgname></affiliation>
-   <productnumber>X Version 11, Release 6.7</productnumber>
+   <releaseinfo>X server version &xserver.version;</releaseinfo>
+   <copyright><year>1989</year><year>1990</year><year>1991</year>
+     <holder>Hewlett-Packard Company</holder>
+   </copyright>
 
 <legalnotice>
 
@@ -36,11 +30,11 @@ Hewlett-Packard makes no representations about the suitability for any purpose o
 document. It is provided "as is" without express or implied warranty. This document is only a draft stan-
 dard of the X Consortium and is therefore subject to change.
 </para>
+</legalnotice>
 
+<legalnotice>
+<para role="multiLicensing">Copyright © 1989, 1990, 1991 X Consortium</para>
 <para>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the &ldquo;Software&rdquo;), 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:</para>
-
-<para>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the &ldquo;Software&rdquo;), 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:</para>
-
 <para>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</para>
 
 <para>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 X CONSORTIUM 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.</para>
diff --git a/xorg-server/doc/Xserver-spec.xml b/xorg-server/doc/Xserver-spec.xml
index b14e4897e..37fd2b29a 100644
--- a/xorg-server/doc/Xserver-spec.xml
+++ b/xorg-server/doc/Xserver-spec.xml
@@ -1,11 +1,14 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
  "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
+ <!ENTITY % xorg-defs SYSTEM "defs.ent"> %xorg-defs;
  <!ENTITY % defs SYSTEM "/xserver/doc/xml/xserver.ent"> %defs;
 ]>
 
 <article>
   <articleinfo>
+    <title>Definition of the Porting Layer for the X v11 Sample Server</title>
+    <titleabbrev>X Porting Layer</titleabbrev>
     <author>
       <firstname>Susan</firstname><surname>Angebranndt</surname>
       <affiliation><orgname>Digital Equipment Corporation</orgname></affiliation>
@@ -39,10 +42,17 @@
       <affiliation><orgname>X.org Foundation and Hewlett Packard</orgname></affiliation>
     </author>
     <publisher><publishername>The X.Org Foundation</publishername></publisher>
-    <pubdate>&xserver.reldate;</pubdate>
+    <releaseinfo>X Version 11, Release &fullrelvers;</releaseinfo>
     <releaseinfo>X server version &xserver.version;</releaseinfo>
-    <title>Definition of the Porting Layer for the X v11 Sample Server</title>
-    <titleabbrev>X Porting Layer</titleabbrev>
+    <copyright><year>1994</year><holder>X Consortium, Inc.</holder></copyright>
+    <copyright><year>2004</year><holder>X.org Foundation, Inc.</holder></copyright>
+    <legalnotice>
+      <para>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:</para>
+      <para>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</para>
+      <para>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 X CONSORTIUM 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.</para>
+      <para>LK201 and DEC are trademarks of Digital Equipment Corporation.  Macintosh and Apple are trademarks of Apple Computer, Inc.  PostScript is a trademark of Adobe Systems, Inc.  Ethernet is a trademark of Xerox Corporation.  X Window System is a trademark of the X.org Foundation, Inc.  Cray is a trademark of Cray Research, Inc.</para>
+    </legalnotice>
+    <pubdate>&xserver.reldate;</pubdate>
     <revhistory>
       <revision>
 	<revnumber>1.0</revnumber>
@@ -100,13 +110,6 @@
 	  and 1.8 CreateNewResourceType changes</revremark>
       </revision>
     </revhistory>
-    <legalnotice>
-      <para>Copyright &#xA9; 1994 X Consortium, Inc., 2004 X.org Foundation, Inc.</para>
-      <para>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:</para>
-      <para>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</para>
-      <para>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 X CONSORTIUM 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.</para>
-      <para>LK201 and DEC are trademarks of Digital Equipment Corporation.  Macintosh and Apple are trademarks of Apple Computer, Inc.  PostScript is a trademark of Adobe Systems, Inc.  Ethernet is a trademark of Xerox Corporation.  X Window System is a trademark of the X.org Foundation, Inc.  Cray is a trademark of Cray Research, Inc.</para>
-    </legalnotice>
     <abstract>
       <para>The following document explains the structure of the X Window System display server and the interfaces among the larger pieces.  It is intended as a reference for programmers who are implementing an X Display Server on their workstation hardware.  It is included with the X Window System source tape, along with the document "Strategies for Porting the X v11 Sample Server."  The order in which you should read these documents is:
       <orderedlist>
diff --git a/xorg-server/doc/dtrace/Xserver-DTrace.xml b/xorg-server/doc/dtrace/Xserver-DTrace.xml
index 72b8f4fa6..fa8bc809a 100644
--- a/xorg-server/doc/dtrace/Xserver-DTrace.xml
+++ b/xorg-server/doc/dtrace/Xserver-DTrace.xml
@@ -1,578 +1,578 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>

-<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"

- "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [

- <!ENTITY % defs SYSTEM "/xserver/doc/xml/xserver.ent"> %defs;

-]>

-

-<article id="Xserver-DTrace">

-  <articleinfo>

-    <title>Xserver provider for DTrace</title>

-    <author>

-      <firstname>Alan</firstname><surname>Coopersmith</surname>

-      <affiliation>

-	<orgname>Oracle Corporation</orgname>

-	<orgdiv>Solaris Engineering</orgdiv>

-      </affiliation>

-    </author>

-    <releaseinfo>X.Org Xserver version &xserver.version;</releaseinfo>

-    <legalnotice>

-      <para>

-Copyright (c) 2005, 2006, 2007, 2010, Oracle and/or its affiliates.

-All rights reserved.

-      </para><para>

-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:

-      </para><para>

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

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

-Software.

-      </para><para>

-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.

-      </para>

-    </legalnotice>

-  </articleinfo>

-

-  <sect1 id="introduction">

-    <title>Introduction</title>

-    <para>

-      This page provides details on a

-      <ulink url="http://wikis.sun.com/display/DTrace/Statically+Defined+Tracing+for+User+Applications">statically defined user application tracing provider</ulink>

-      for the

-      <ulink url="http://hub.opensolaris.org/bin/view/Community+Group+dtrace/">DTrace</ulink>

-      facility in <productname>Solaris</productname> 10,

-      <productname>MacOS X</productname> 10.5, and later releases.  This

-      provider instruments various points in the X server, to allow

-      tracing what client applications are up to.

-    </para>

-

-    <para>

-      The provider was integrated into the X.Org git master repository

-      with Solaris 10 &amp; OpenSolaris support for the Xserver 1.4 release,

-      released in 2007 with X11R7.3.   Support for DTrace on MacOS X

-      was added in Xserver 1.7.

-    </para>

-

-    <para>

-      These probes expose the request and reply structure of the X protocol

-      between clients and the X server, so an understanding of that basic

-      nature will aid in learning how to use these probes.

-    </para>

-  </sect1>

-

-  <sect1 id="probes">

-    <title>Available probes</title>

-

-    <para>

-      Due to the way User-Defined DTrace probes work, arguments to

-      these probes all bear undistinguished names of

-      <parameter>arg0</parameter>, <parameter>arg1</parameter>,

-      <parameter>arg2</parameter>, etc.  These tables should help you

-      determine what the real data is for each of the probe arguments.

-

-    <table>

-      <title>Probes and their arguments</title>

-      <tgroup cols='7'>

-	<colspec colname="probe" colwidth="2*"/>

-	<colspec colname="desc" colwidth="3*"/>

-	<colspec colname="arg0" colwidth="1*"/>

-	<colspec colname="arg1" colwidth="1*"/>

-	<colspec colname="arg2" colwidth="1*"/>

-	<colspec colname="arg3" colwidth="1*"/>

-	<colspec colname="arg4" colwidth="1*"/>

-	<spanspec spanname="all" namest="probe" nameend="arg4"/>

-	<thead>

-	  <row>

-	    <entry>Probe name</entry>

-	    <entry>Description</entry>

-	    <entry>arg0</entry>

-	    <entry>arg1</entry>

-	    <entry>arg2</entry>

-	    <entry>arg3</entry>

-	    <entry>arg4</entry>

-	  </row>

-	</thead>

-	<tbody>

-	  <row>

-	    <entry spanname="all" class="grouphead">Request Probes</entry>

-	  </row>

-	  <row>

-	    <entry>request-start</entry>

-	    <entry>Called just before processing each client request.</entry>

-	    <entry><parameter>requestName</parameter></entry>

-	    <entry><parameter>requestCode</parameter></entry>

-	    <entry><parameter>requestLength</parameter></entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><parameter>requestBuffer</parameter></entry>

-	  </row>

-	  <row>

-	    <entry>request-done</entry>

-	    <entry>Called just after processing each client request.</entry>

-	    <entry><parameter>requestName</parameter></entry>

-	    <entry><parameter>requestCode</parameter></entry>

-	    <entry><parameter>sequenceNumber</parameter></entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><parameter>resultCode</parameter></entry>

-	  </row>

-	  <row>

-	    <entry spanname="all" class="grouphead">Event Probes</entry>

-	  </row>

-	  <row>

-	    <entry>send-event</entry>

-	    <entry>Called just before send each event to a client.</entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><parameter>eventCode</parameter></entry>

-	    <entry><parameter>eventBuffer</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	  <row>

-	    <entry spanname="all" class="grouphead">Client Connection Probes</entry>

-	  </row>

-	  <row>

-	    <entry>client-connect</entry>

-	    <entry>Called when a new connection is opened from a client</entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><parameter>clientFD</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	  <row>

-	    <entry>client-auth</entry>

-	    <entry>Called when client authenticates (normally just after connection opened)</entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><parameter>clientAddr</parameter></entry>

-	    <entry><parameter>clientPid</parameter></entry>

-	    <entry><parameter>clientZoneId</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	  <row>

-	    <entry>client-disconnect</entry>

-	    <entry>Called when a client connection is closed</entry>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	  <row>

-	    <entry spanname="all" class="grouphead">Resource Allocation Probes</entry>

-	  </row>

-	  <row>

-	    <entry>resource-alloc</entry>

-	    <entry>Called when a new resource (pixmap, gc, colormap, etc.) is allocated</entry>

-	    <entry><parameter>resourceId</parameter></entry>

-	    <entry><parameter>resourceTypeId</parameter></entry>

-	    <entry><parameter>resourceValue</parameter></entry>

-	    <entry><parameter>resourceTypeName</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	  <row>

-	    <entry>resource-free</entry>

-	    <entry>Called when a resource is freed</entry>

-	    <entry><parameter>resourceId</parameter></entry>

-	    <entry><parameter>resourceTypeId</parameter></entry>

-	    <entry><parameter>resourceValue</parameter></entry>

-	    <entry><parameter>resourceTypeName</parameter></entry>

-	    <entry nameend="arg4" class="unused"/>

-	  </row>

-	</tbody>

-      </tgroup>

-    </table>

-    </para>

-  </sect1>

-

-  <sect1 id="arguments">

-    <title>Data Available in Probe Arguments</title>

-

-    <para>

-      To access data in arguments of type <type>string</type>, you will need

-      to use <ulink url="http://wikis.sun.com/display/DTrace/Actions+and+Subroutines#ActionsandSubroutines-{{copyinstr}}"><function>copyinstr()</function></ulink>.

-      To access data buffers referenced via <type>uintptr_t</type>'s, you will

-      need to use <ulink url="http://wikis.sun.com/display/DTrace/Actions+and+Subroutines#ActionsandSubroutines-{{copyin}}"><function>copyin()</function></ulink>.

-

-    <table>

-      <title>Probe Arguments</title>

-      <tgroup cols='3'>

-	<colspec colname="arg" colwidth="2*"/>

-	<colspec colname="type" colwidth="1*"/>

-	<colspec colname="desc" colwidth="7*"/>

-	<thead>

-	  <row>

-	    <entry>Argument name</entry>

-	    <entry>Type</entry>

-	    <entry>Description</entry>

-	  </row>

-	</thead>

-	<tbody>

-	  <row>

-	    <entry><parameter>clientAddr</parameter></entry>

-	    <entry><type>string</type></entry>

-	    <entry>String representing address client connected from</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>clientFD</parameter></entry>

-	    <entry><type>int</type></entry>

-	    <entry>X server's file descriptor for server side of each connection</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>clientId</parameter></entry>

-	    <entry><type>int</type></entry>

-	    <entry>Unique integer identifier for each connection to the

-	      X server</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>clientPid</parameter></entry>

-	    <entry><type>pid_t</type></entry>

-	    <entry>Process id of client, if connection is local

-	      (from <function>getpeerucred()</function>)</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>clientZoneId</parameter></entry>

-	    <entry><type>zoneid_t</type></entry>

-	    <entry>Solaris: Zone id of client, if connection is local

-	      (from <function>getpeerucred()</function>)</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>eventBuffer</parameter></entry>

-	    <entry><type>uintptr_t</type></entry>

-	    <entry>Pointer to buffer containing X event - decode using

-	      structures in

-	      &lt;<ulink url="http://cgit.freedesktop.org/xorg/proto/xproto/tree/Xproto.h"><filename class="headerfile">X11/Xproto.h</filename></ulink>&gt;

-	      and similar headers for each extension</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>eventCode</parameter></entry>

-	    <entry><type>uint8_t</type></entry>

-	    <entry>Event number of X event</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>resourceId</parameter></entry>

-	    <entry><type>uint32_t</type></entry>

-	    <entry>X resource id (XID)</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>resourceTypeId</parameter></entry>

-	    <entry><type>uint32_t</type></entry>

-	    <entry>Resource type id</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>resourceTypeName</parameter></entry>

-	    <entry><type>string</type></entry>

-	    <entry>String representing X resource type

-		(<literal>"PIXMAP"</literal>, etc.)</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>resourceValue</parameter></entry>

-	    <entry><type>uintptr_t</type></entry>

-	    <entry>Pointer to data for X resource</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>resultCode</parameter></entry>

-	    <entry><type>int</type></entry>

-	    <entry>Integer code representing result status of request</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>requestBuffer</parameter></entry>

-	    <entry><type>uintptr_t</type></entry>

-	    <entry>Pointer to buffer containing X request - decode using

-	      structures in

-	      &lt;<ulink url="http://cgit.freedesktop.org/xorg/proto/xproto/tree/Xproto.h"><filename class="headerfile">X11/Xproto.h</filename></ulink>&gt;

-	      and similar headers for each extension</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>requestCode</parameter></entry>

-	    <entry><type>uint8_t</type></entry>

-	    <entry>Request number of X request or Extension</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>requestName</parameter></entry>

-	    <entry><type>string</type></entry>

-	    <entry>Name of X request or Extension</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>requestLength</parameter></entry>

-	    <entry><type>uint16_t</type></entry>

-	    <entry>Length of X request</entry>

-	  </row>

-	  <row>

-	    <entry><parameter>sequenceNumber</parameter></entry>

-	    <entry><type>uint32_t</type></entry>

-	    <entry>Number of X request in in this connection</entry>

-	  </row>

-	</tbody>

-      </tgroup>

-    </table>

-    </para>

-  </sect1>

-

-  <sect1 id="examples">

-    <title>Examples</title>

-

-    <example>

-      <title>Counting requests by request name</title>

-

-      <para>

-	This script simply increments a counter for each different request

-	made, and when you exit the script (such as by hitting

-	<keycombo action='simul'><keycap>Control</keycap><keycap>C</keycap>

-	</keycombo>) prints the counts.

-

-	<programlisting>

-#!/usr/sbin/dtrace -s

-

-Xserver*:::request-start

-{

-    @counts[copyinstr(arg0)] = count();

-}

-	</programlisting>

-

-	The output from a short run may appear as:

-	<screen>

-  QueryPointer                                                      1

-  CreatePixmap                                                      2

-  FreePixmap                                                        2

-  PutImage                                                          2

-  ChangeGC                                                         10

-  CopyArea                                                         10

-  CreateGC                                                         14

-  FreeGC                                                           14

-  RENDER                                                           28

-  SetClipRectangles                                                40

-	</screen>

-      </para>

-

-      <para>

-	This can be rewritten slightly to cache the string containing the name

-	of the request since it will be reused many times, instead of copying

-	it over and over from the kernel:

-

-	<programlisting>

-#!/usr/sbin/dtrace -s

-

-string Xrequest[uintptr_t];

-

-Xserver*:::request-start

-/Xrequest[arg0] == ""/

-{

-    Xrequest[arg0] = copyinstr(arg0);

-}

-

-Xserver*:::request-start

-{

-    @counts[Xrequest[arg0]] = count();

-}

-	</programlisting>

-      </para>

-    </example>

-

-    <example>

-      <title>Get average CPU time per request</title>

-

-      <para>This script records the CPU time used between the probes at

-	the start and end of each request and aggregates it per request type.

-

-	<programlisting>

-#!/usr/sbin/dtrace -s

-

-Xserver*:::request-start

-{

-    reqstart = vtimestamp;

-}

-

-Xserver*:::request-done

-{

-    @times[copyinstr(arg0)] = avg(vtimestamp - reqstart);

-}

-	</programlisting>

-

-	The output from a sample run might look like:

-

-	<screen>

-  ChangeGC                                                        889

-  MapWindow                                                       907

-  SetClipRectangles                                              1319

-  PolyPoint                                                      1413

-  PolySegment                                                    1434

-  PolyRectangle                                                  1828

-  FreeCursor                                                     1895

-  FreeGC                                                         1950

-  CreateGC                                                       2244

-  FreePixmap                                                     2246

-  GetInputFocus                                                  2249

-  TranslateCoords                                                8508

-  QueryTree                                                      8846

-  GetGeometry                                                    9948

-  CreatePixmap                                                  12111

-  AllowEvents                                                   14090

-  GrabServer                                                    14791

-  MIT-SCREEN-SAVER                                              16747

-  ConfigureWindow                                               22917

-  SetInputFocus                                                 28521

-  PutImage                                                     240841

-

-	</screen>

-      </para>

-    </example>

-

-    <example>

-      <title>Monitoring clients that connect and disconnect</title>

-

-      <para>

-	This script simply prints information about each client that

-	connects or disconnects from the server while it is running.

-	Since the provider is specified as <code>Xserver$1</code> instead

-	of <code>Xserver*</code> like previous examples, it won't monitor

-	all Xserver processes running on the machine, but instead expects

-	the process id of the X server to monitor to be specified as the

-	argument to the script.

-

-	<programlisting>

-#!/usr/sbin/dtrace -s

-

-Xserver$1:::client-connect

-{

-	printf("** Client Connect: id %d\n", arg0);

-}

-

-Xserver$1:::client-auth

-{

-	printf("** Client auth'ed: id %d =&gt; %s pid %d\n",

-		arg0, copyinstr(arg1), arg2);

-}

-

-Xserver$1:::client-disconnect

-{

-	printf("** Client Disconnect: id %d\n", arg0);

-}

-	</programlisting>

-

-	A sample run:

-

-	<screen>

-<prompt>#</prompt> <userinput>./foo.d 5790</userinput>

-<computeroutput>dtrace: script './foo.d' matched 4 probes

-CPU     ID                    FUNCTION:NAME

-  0  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 65

-

-  2  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 64

-

-  0  15773 EstablishNewConnections:client-connect ** Client Connect: id 64

-

-  0  15772            AuthAudit:client-auth ** Client auth'ed: id 64 =&gt; local host pid 2034

-

-  0  15773 EstablishNewConnections:client-connect ** Client Connect: id 65

-

-  0  15772            AuthAudit:client-auth ** Client auth'ed: id 65 =&gt; local host pid 2034

-

-  0  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 64

-	  </computeroutput>

-	</screen>

-

-      </para>

-    </example>

-

-    <example>

-      <title>Monitoring clients creating Pixmaps</title>

-

-      <para>

-	This script can be used to determine which clients are creating

-	pixmaps in the X server, printing information about each client

-	as it connects to help trace it back to the program on the other

-	end of the X connection.

-

-	<programlisting>

-#!/usr/sbin/dtrace -qs

-

-string Xrequest[uintptr_t];

-string Xrestype[uintptr_t];

-

-Xserver$1:::request-start

-/Xrequest[arg0] == ""/

-{

-	Xrequest[arg0] = copyinstr(arg0);

-}

-

-Xserver$1:::resource-alloc

-/arg3 != 0 &amp;&amp; Xrestype[arg3] == ""/

-{

-	Xrestype[arg3] = copyinstr(arg3);

-}

-

-

-Xserver$1:::request-start

-/Xrequest[arg0] == "X_CreatePixmap"/

-{

-	printf("-&gt; %s: client %d\n", Xrequest[arg0], arg3);

-}

-

-Xserver$1:::request-done

-/Xrequest[arg0] == "X_CreatePixmap"/

-{

-	printf("&lt;- %s: client %d\n", Xrequest[arg0], arg3);

-}

-

-Xserver$1:::resource-alloc

-/Xrestype[arg3] == "PIXMAP"/

-{

-	printf("** Pixmap alloc: %08x\n", arg0);

-}

-

-

-Xserver$1:::resource-free

-/Xrestype[arg3] == "PIXMAP"/

-{

-	printf("** Pixmap free:  %08x\n", arg0);

-}

-

-Xserver$1:::client-connect

-{

-	printf("** Client Connect: id %d\n", arg0);

-}

-

-Xserver$1:::client-auth

-{

-	printf("** Client auth'ed: id %d =&gt; %s pid %d\n",

-		arg0, copyinstr(arg1), arg2);

-}

-

-Xserver$1:::client-disconnect

-{

-	printf("** Client Disconnect: id %d\n", arg0);

-}

-	</programlisting>

-

-	Sample output from a run of this script:

-	<screen><computeroutput>

-** Client Connect: id 17

-** Client auth'ed: id 17 =&gt; local host pid 20273

--&gt; X_CreatePixmap: client 17

-** Pixmap alloc: 02200009

-&lt;- X_CreatePixmap: client 17

--&gt; X_CreatePixmap: client 15

-** Pixmap alloc: 01e00180

-&lt;- X_CreatePixmap: client 15

--&gt; X_CreatePixmap: client 15

-** Pixmap alloc: 01e00181

-&lt;- X_CreatePixmap: client 15

--&gt; X_CreatePixmap: client 14

-** Pixmap alloc: 01c004c8

-&lt;- X_CreatePixmap: client 14

-** Pixmap free:  02200009

-** Client Disconnect: id 17

-** Pixmap free:  01e00180

-** Pixmap free:  01e00181

-	  </computeroutput></screen>

-

-      </para>

-

-    </example>

-

-

-  </sect1>

-

-</article>

+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
+ "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
+ <!ENTITY % defs SYSTEM "/xserver/doc/xml/xserver.ent"> %defs;
+]>
+
+<article id="Xserver-DTrace">
+  <articleinfo>
+    <title>Xserver Provider for DTrace</title>
+    <author>
+      <firstname>Alan</firstname><surname>Coopersmith</surname>
+      <affiliation>
+	<orgname>Oracle Corporation</orgname>
+	<orgdiv>Solaris Engineering</orgdiv>
+      </affiliation>
+    </author>
+    <releaseinfo>X.Org Xserver version &xserver.version;</releaseinfo>
+    <copyright><year>2005</year><year>2006</year><year>2007</year><year>2010</year>
+      <holder>Oracle and/or its affiliates. All rights reserved.</holder>
+    </copyright>
+    <legalnotice id="copyright">
+      <para>
+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:
+      </para><para>
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+      </para><para>
+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.
+      </para>
+    </legalnotice>
+  </articleinfo>
+
+  <sect1 id="introduction">
+    <title>Introduction</title>
+    <para>
+      This page provides details on a
+      <ulink url="http://wikis.sun.com/display/DTrace/Statically+Defined+Tracing+for+User+Applications">statically defined user application tracing provider</ulink>
+      for the
+      <ulink url="http://hub.opensolaris.org/bin/view/Community+Group+dtrace/">DTrace</ulink>
+      facility in <productname>Solaris</productname> 10,
+      <productname>MacOS X</productname> 10.5, and later releases.  This
+      provider instruments various points in the X server, to allow
+      tracing what client applications are up to.
+    </para>
+
+    <para>
+      The provider was integrated into the X.Org git master repository
+      with Solaris 10 &amp; OpenSolaris support for the Xserver 1.4 release,
+      released in 2007 with X11R7.3.   Support for DTrace on MacOS X
+      was added in Xserver 1.7.
+    </para>
+
+    <para>
+      These probes expose the request and reply structure of the X protocol
+      between clients and the X server, so an understanding of that basic
+      nature will aid in learning how to use these probes.
+    </para>
+  </sect1>
+
+  <sect1 id="probes">
+    <title>Available probes</title>
+
+    <para>
+      Due to the way User-Defined DTrace probes work, arguments to
+      these probes all bear undistinguished names of
+      <parameter>arg0</parameter>, <parameter>arg1</parameter>,
+      <parameter>arg2</parameter>, etc.  These tables should help you
+      determine what the real data is for each of the probe arguments.
+
+    <table id="Probes_and_their_arguments">
+      <title>Probes and their arguments</title>
+      <tgroup cols='7'>
+	<colspec colname="probe" colwidth="2*"/>
+	<colspec colname="desc" colwidth="3*"/>
+	<colspec colname="arg0" colwidth="1*"/>
+	<colspec colname="arg1" colwidth="1*"/>
+	<colspec colname="arg2" colwidth="1*"/>
+	<colspec colname="arg3" colwidth="1*"/>
+	<colspec colname="arg4" colwidth="1*"/>
+	<spanspec spanname="all" namest="probe" nameend="arg4"/>
+	<thead>
+	  <row>
+	    <entry>Probe name</entry>
+	    <entry>Description</entry>
+	    <entry>arg0</entry>
+	    <entry>arg1</entry>
+	    <entry>arg2</entry>
+	    <entry>arg3</entry>
+	    <entry>arg4</entry>
+	  </row>
+	</thead>
+	<tbody>
+	  <row>
+	    <entry spanname="all" class="grouphead">Request Probes</entry>
+	  </row>
+	  <row>
+	    <entry>request-start</entry>
+	    <entry>Called just before processing each client request.</entry>
+	    <entry><parameter>requestName</parameter></entry>
+	    <entry><parameter>requestCode</parameter></entry>
+	    <entry><parameter>requestLength</parameter></entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><parameter>requestBuffer</parameter></entry>
+	  </row>
+	  <row>
+	    <entry>request-done</entry>
+	    <entry>Called just after processing each client request.</entry>
+	    <entry><parameter>requestName</parameter></entry>
+	    <entry><parameter>requestCode</parameter></entry>
+	    <entry><parameter>sequenceNumber</parameter></entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><parameter>resultCode</parameter></entry>
+	  </row>
+	  <row>
+	    <entry spanname="all" class="grouphead">Event Probes</entry>
+	  </row>
+	  <row>
+	    <entry>send-event</entry>
+	    <entry>Called just before send each event to a client.</entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><parameter>eventCode</parameter></entry>
+	    <entry><parameter>eventBuffer</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	  <row>
+	    <entry spanname="all" class="grouphead">Client Connection Probes</entry>
+	  </row>
+	  <row>
+	    <entry>client-connect</entry>
+	    <entry>Called when a new connection is opened from a client</entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><parameter>clientFD</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	  <row>
+	    <entry>client-auth</entry>
+	    <entry>Called when client authenticates (normally just after connection opened)</entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><parameter>clientAddr</parameter></entry>
+	    <entry><parameter>clientPid</parameter></entry>
+	    <entry><parameter>clientZoneId</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	  <row>
+	    <entry>client-disconnect</entry>
+	    <entry>Called when a client connection is closed</entry>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	  <row>
+	    <entry spanname="all" class="grouphead">Resource Allocation Probes</entry>
+	  </row>
+	  <row>
+	    <entry>resource-alloc</entry>
+	    <entry>Called when a new resource (pixmap, gc, colormap, etc.) is allocated</entry>
+	    <entry><parameter>resourceId</parameter></entry>
+	    <entry><parameter>resourceTypeId</parameter></entry>
+	    <entry><parameter>resourceValue</parameter></entry>
+	    <entry><parameter>resourceTypeName</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	  <row>
+	    <entry>resource-free</entry>
+	    <entry>Called when a resource is freed</entry>
+	    <entry><parameter>resourceId</parameter></entry>
+	    <entry><parameter>resourceTypeId</parameter></entry>
+	    <entry><parameter>resourceValue</parameter></entry>
+	    <entry><parameter>resourceTypeName</parameter></entry>
+	    <entry nameend="arg4" class="unused"/>
+	  </row>
+	</tbody>
+      </tgroup>
+    </table>
+    </para>
+  </sect1>
+
+  <sect1 id="arguments">
+    <title>Data Available in Probe Arguments</title>
+
+    <para>
+      To access data in arguments of type <type>string</type>, you will need
+      to use <ulink url="http://wikis.sun.com/display/DTrace/Actions+and+Subroutines#ActionsandSubroutines-{{copyinstr}}"><function>copyinstr()</function></ulink>.
+      To access data buffers referenced via <type>uintptr_t</type>'s, you will
+      need to use <ulink url="http://wikis.sun.com/display/DTrace/Actions+and+Subroutines#ActionsandSubroutines-{{copyin}}"><function>copyin()</function></ulink>.
+
+    <table id="Probe_Arguments">
+      <title>Probe Arguments</title>
+      <tgroup cols='3'>
+	<colspec colname="arg" colwidth="2*"/>
+	<colspec colname="type" colwidth="1*"/>
+	<colspec colname="desc" colwidth="7*"/>
+	<thead>
+	  <row>
+	    <entry>Argument name</entry>
+	    <entry>Type</entry>
+	    <entry>Description</entry>
+	  </row>
+	</thead>
+	<tbody>
+	  <row>
+	    <entry><parameter>clientAddr</parameter></entry>
+	    <entry><type>string</type></entry>
+	    <entry>String representing address client connected from</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>clientFD</parameter></entry>
+	    <entry><type>int</type></entry>
+	    <entry>X server's file descriptor for server side of each connection</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>clientId</parameter></entry>
+	    <entry><type>int</type></entry>
+	    <entry>Unique integer identifier for each connection to the
+	      X server</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>clientPid</parameter></entry>
+	    <entry><type>pid_t</type></entry>
+	    <entry>Process id of client, if connection is local
+	      (from <function>getpeerucred()</function>)</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>clientZoneId</parameter></entry>
+	    <entry><type>zoneid_t</type></entry>
+	    <entry>Solaris: Zone id of client, if connection is local
+	      (from <function>getpeerucred()</function>)</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>eventBuffer</parameter></entry>
+	    <entry><type>uintptr_t</type></entry>
+	    <entry>Pointer to buffer containing X event - decode using
+	      structures in
+	      &lt;<ulink url="http://cgit.freedesktop.org/xorg/proto/xproto/tree/Xproto.h"><filename class="headerfile">X11/Xproto.h</filename></ulink>&gt;
+	      and similar headers for each extension</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>eventCode</parameter></entry>
+	    <entry><type>uint8_t</type></entry>
+	    <entry>Event number of X event</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>resourceId</parameter></entry>
+	    <entry><type>uint32_t</type></entry>
+	    <entry>X resource id (XID)</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>resourceTypeId</parameter></entry>
+	    <entry><type>uint32_t</type></entry>
+	    <entry>Resource type id</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>resourceTypeName</parameter></entry>
+	    <entry><type>string</type></entry>
+	    <entry>String representing X resource type
+		(<literal>"PIXMAP"</literal>, etc.)</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>resourceValue</parameter></entry>
+	    <entry><type>uintptr_t</type></entry>
+	    <entry>Pointer to data for X resource</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>resultCode</parameter></entry>
+	    <entry><type>int</type></entry>
+	    <entry>Integer code representing result status of request</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>requestBuffer</parameter></entry>
+	    <entry><type>uintptr_t</type></entry>
+	    <entry>Pointer to buffer containing X request - decode using
+	      structures in
+	      &lt;<ulink url="http://cgit.freedesktop.org/xorg/proto/xproto/tree/Xproto.h"><filename class="headerfile">X11/Xproto.h</filename></ulink>&gt;
+	      and similar headers for each extension</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>requestCode</parameter></entry>
+	    <entry><type>uint8_t</type></entry>
+	    <entry>Request number of X request or Extension</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>requestName</parameter></entry>
+	    <entry><type>string</type></entry>
+	    <entry>Name of X request or Extension</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>requestLength</parameter></entry>
+	    <entry><type>uint16_t</type></entry>
+	    <entry>Length of X request</entry>
+	  </row>
+	  <row>
+	    <entry><parameter>sequenceNumber</parameter></entry>
+	    <entry><type>uint32_t</type></entry>
+	    <entry>Number of X request in in this connection</entry>
+	  </row>
+	</tbody>
+      </tgroup>
+    </table>
+    </para>
+  </sect1>
+
+  <sect1 id="examples">
+    <title>Examples</title>
+
+    <example id="Counting_requests_by_request_name">
+      <title>Counting requests by request name</title>
+
+      <para>
+	This script simply increments a counter for each different request
+	made, and when you exit the script (such as by hitting
+	<keycombo action='simul'><keycap>Control</keycap><keycap>C</keycap>
+	</keycombo>) prints the counts.
+
+	<programlisting>
+#!/usr/sbin/dtrace -s
+
+Xserver*:::request-start
+{
+    @counts[copyinstr(arg0)] = count();
+}
+	</programlisting>
+
+	The output from a short run may appear as:
+	<screen>
+  QueryPointer                                                      1
+  CreatePixmap                                                      2
+  FreePixmap                                                        2
+  PutImage                                                          2
+  ChangeGC                                                         10
+  CopyArea                                                         10
+  CreateGC                                                         14
+  FreeGC                                                           14
+  RENDER                                                           28
+  SetClipRectangles                                                40
+	</screen>
+      </para>
+
+      <para>
+	This can be rewritten slightly to cache the string containing the name
+	of the request since it will be reused many times, instead of copying
+	it over and over from the kernel:
+
+	<programlisting>
+#!/usr/sbin/dtrace -s
+
+string Xrequest[uintptr_t];
+
+Xserver*:::request-start
+/Xrequest[arg0] == ""/
+{
+    Xrequest[arg0] = copyinstr(arg0);
+}
+
+Xserver*:::request-start
+{
+    @counts[Xrequest[arg0]] = count();
+}
+	</programlisting>
+      </para>
+    </example>
+
+    <example id="Get_average_CPU_time_per_request">
+      <title>Get average CPU time per request</title>
+
+      <para>This script records the CPU time used between the probes at
+	the start and end of each request and aggregates it per request type.
+
+	<programlisting>
+#!/usr/sbin/dtrace -s
+
+Xserver*:::request-start
+{
+    reqstart = vtimestamp;
+}
+
+Xserver*:::request-done
+{
+    @times[copyinstr(arg0)] = avg(vtimestamp - reqstart);
+}
+	</programlisting>
+
+	The output from a sample run might look like:
+
+	<screen>
+  ChangeGC                                                        889
+  MapWindow                                                       907
+  SetClipRectangles                                              1319
+  PolyPoint                                                      1413
+  PolySegment                                                    1434
+  PolyRectangle                                                  1828
+  FreeCursor                                                     1895
+  FreeGC                                                         1950
+  CreateGC                                                       2244
+  FreePixmap                                                     2246
+  GetInputFocus                                                  2249
+  TranslateCoords                                                8508
+  QueryTree                                                      8846
+  GetGeometry                                                    9948
+  CreatePixmap                                                  12111
+  AllowEvents                                                   14090
+  GrabServer                                                    14791
+  MIT-SCREEN-SAVER                                              16747
+  ConfigureWindow                                               22917
+  SetInputFocus                                                 28521
+  PutImage                                                     240841
+
+	</screen>
+      </para>
+    </example>
+
+    <example id="Monitoring_clients_that_connect_and_disconnect">
+      <title>Monitoring clients that connect and disconnect</title>
+
+      <para>
+	This script simply prints information about each client that
+	connects or disconnects from the server while it is running.
+	Since the provider is specified as <code>Xserver$1</code> instead
+	of <code>Xserver*</code> like previous examples, it won't monitor
+	all Xserver processes running on the machine, but instead expects
+	the process id of the X server to monitor to be specified as the
+	argument to the script.
+
+	<programlisting>
+#!/usr/sbin/dtrace -s
+
+Xserver$1:::client-connect
+{
+	printf("** Client Connect: id %d\n", arg0);
+}
+
+Xserver$1:::client-auth
+{
+	printf("** Client auth'ed: id %d =&gt; %s pid %d\n",
+		arg0, copyinstr(arg1), arg2);
+}
+
+Xserver$1:::client-disconnect
+{
+	printf("** Client Disconnect: id %d\n", arg0);
+}
+	</programlisting>
+
+	A sample run:
+
+	<screen>
+<prompt>#</prompt> <userinput>./foo.d 5790</userinput>
+<computeroutput>dtrace: script './foo.d' matched 4 probes
+CPU     ID                    FUNCTION:NAME
+  0  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 65
+
+  2  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 64
+
+  0  15773 EstablishNewConnections:client-connect ** Client Connect: id 64
+
+  0  15772            AuthAudit:client-auth ** Client auth'ed: id 64 =&gt; local host pid 2034
+
+  0  15773 EstablishNewConnections:client-connect ** Client Connect: id 65
+
+  0  15772            AuthAudit:client-auth ** Client auth'ed: id 65 =&gt; local host pid 2034
+
+  0  15774 CloseDownClient:client-disconnect ** Client Disconnect: id 64
+	  </computeroutput>
+	</screen>
+
+      </para>
+    </example>
+
+    <example id="Monitoring_clients_creating_Pixmaps">
+      <title>Monitoring clients creating Pixmaps</title>
+
+      <para>
+	This script can be used to determine which clients are creating
+	pixmaps in the X server, printing information about each client
+	as it connects to help trace it back to the program on the other
+	end of the X connection.
+
+	<programlisting>
+#!/usr/sbin/dtrace -qs
+
+string Xrequest[uintptr_t];
+string Xrestype[uintptr_t];
+
+Xserver$1:::request-start
+/Xrequest[arg0] == ""/
+{
+	Xrequest[arg0] = copyinstr(arg0);
+}
+
+Xserver$1:::resource-alloc
+/arg3 != 0 &amp;&amp; Xrestype[arg3] == ""/
+{
+	Xrestype[arg3] = copyinstr(arg3);
+}
+
+
+Xserver$1:::request-start
+/Xrequest[arg0] == "X_CreatePixmap"/
+{
+	printf("-&gt; %s: client %d\n", Xrequest[arg0], arg3);
+}
+
+Xserver$1:::request-done
+/Xrequest[arg0] == "X_CreatePixmap"/
+{
+	printf("&lt;- %s: client %d\n", Xrequest[arg0], arg3);
+}
+
+Xserver$1:::resource-alloc
+/Xrestype[arg3] == "PIXMAP"/
+{
+	printf("** Pixmap alloc: %08x\n", arg0);
+}
+
+
+Xserver$1:::resource-free
+/Xrestype[arg3] == "PIXMAP"/
+{
+	printf("** Pixmap free:  %08x\n", arg0);
+}
+
+Xserver$1:::client-connect
+{
+	printf("** Client Connect: id %d\n", arg0);
+}
+
+Xserver$1:::client-auth
+{
+	printf("** Client auth'ed: id %d =&gt; %s pid %d\n",
+		arg0, copyinstr(arg1), arg2);
+}
+
+Xserver$1:::client-disconnect
+{
+	printf("** Client Disconnect: id %d\n", arg0);
+}
+	</programlisting>
+
+	Sample output from a run of this script:
+	<screen><computeroutput>
+** Client Connect: id 17
+** Client auth'ed: id 17 =&gt; local host pid 20273
+-&gt; X_CreatePixmap: client 17
+** Pixmap alloc: 02200009
+&lt;- X_CreatePixmap: client 17
+-&gt; X_CreatePixmap: client 15
+** Pixmap alloc: 01e00180
+&lt;- X_CreatePixmap: client 15
+-&gt; X_CreatePixmap: client 15
+** Pixmap alloc: 01e00181
+&lt;- X_CreatePixmap: client 15
+-&gt; X_CreatePixmap: client 14
+** Pixmap alloc: 01c004c8
+&lt;- X_CreatePixmap: client 14
+** Pixmap free:  02200009
+** Client Disconnect: id 17
+** Pixmap free:  01e00180
+** Pixmap free:  01e00181
+	  </computeroutput></screen>
+
+      </para>
+
+    </example>
+
+
+  </sect1>
+
+</article>
diff --git a/xorg-server/fb/fbpict.c b/xorg-server/fb/fbpict.c
index d1fd0cbbd..57c93fd06 100644
--- a/xorg-server/fb/fbpict.c
+++ b/xorg-server/fb/fbpict.c
@@ -163,7 +163,9 @@ create_bits_picture (PicturePtr pict,
 	(pixman_format_code_t)pict->format,
 	pixmap->drawable.width, pixmap->drawable.height,
 	(uint32_t *)bits, stride * sizeof (FbStride));
-    
+
+    if (!image)
+	return NULL;
     
 #ifdef FB_ACCESS_WRAPPER
 #if FB_SHIFT==5
diff --git a/xorg-server/hw/kdrive/src/kinfo.c b/xorg-server/hw/kdrive/src/kinfo.c
index 7055fbf4a..0055b16db 100644
--- a/xorg-server/hw/kdrive/src/kinfo.c
+++ b/xorg-server/hw/kdrive/src/kinfo.c
@@ -134,19 +134,9 @@ KdNewPointer (void)
 void
 KdFreePointer(KdPointerInfo *pi)
 {
-    InputOption *option, *prev = NULL;
-
     free(pi->name);
     free(pi->path);
-
-    for (option = pi->options; option; option = option->next) {
-        free(prev);
-        free(option->key);
-        free(option->value);
-        prev = option;
-    }
-
-    free(prev);
+    input_option_free_list(&pi->options);
     free(pi);
 }
 
diff --git a/xorg-server/hw/xfree86/Makefile.am b/xorg-server/hw/xfree86/Makefile.am
index e3ef14fc1..4f0877290 100644
--- a/xorg-server/hw/xfree86/Makefile.am
+++ b/xorg-server/hw/xfree86/Makefile.am
@@ -111,7 +111,7 @@ CLEANFILES = sdksyms.c sdksyms.dep
 EXTRA_DIST += sdksyms.sh
 
 sdksyms.dep sdksyms.c: sdksyms.sh
-	CPP='$(CPP)' AWK='$(AWK)' $(srcdir)/sdksyms.sh $(top_srcdir) $(CFLAGS) $(AM_CFLAGS) $(INCLUDES)
+	CPP='$(CPP)' AWK='$(AWK)' $(SHELL) $(srcdir)/sdksyms.sh $(top_srcdir) $(CFLAGS) $(AM_CFLAGS) $(INCLUDES)
 
 SDKSYMS_DEP = sdksyms.dep
 include $(SDKSYMS_DEP)
diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index e6c4d8f9f..f8c1b6567 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -670,7 +670,6 @@ typedef enum {
     FLAG_DISABLEVIDMODE,
     FLAG_ALLOWNONLOCAL,
     FLAG_ALLOWMOUSEOPENFAIL,
-    FLAG_VTSYSREQ,
     FLAG_SAVER_BLANKTIME,
     FLAG_DPMS_STANDBYTIME,
     FLAG_DPMS_SUSPENDTIME,
@@ -711,8 +710,6 @@ static OptionInfoRec FlagOptions[] = {
 	{0}, FALSE },
   { FLAG_ALLOWMOUSEOPENFAIL,	"AllowMouseOpenFail",		OPTV_BOOLEAN,
 	{0}, FALSE },
-  { FLAG_VTSYSREQ,		"VTSysReq",			OPTV_BOOLEAN,
-	{0}, FALSE },
   { FLAG_SAVER_BLANKTIME,	"BlankTime"		,	OPTV_INTEGER,
 	{0}, FALSE },
   { FLAG_DPMS_STANDBYTIME,	"StandbyTime",			OPTV_INTEGER,
@@ -850,16 +847,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     if (xf86GetOptValBool(FlagOptions, FLAG_ALLOWMOUSEOPENFAIL, &value))
 	xf86Info.allowMouseOpenFail = value;
 
-    if (xf86GetOptValBool(FlagOptions, FLAG_VTSYSREQ, &value)) {
-#ifdef USE_VT_SYSREQ
-	xf86Info.vtSysreq = value;
-	xf86Msg(X_CONFIG, "VTSysReq %s\n", value ? "enabled" : "disabled");
-#else
-	if (value)
-	    xf86Msg(X_WARNING, "VTSysReq is not supported on this OS\n");
-#endif
-    }
-
     xf86Info.pmFlag = TRUE;
     if (xf86GetOptValBool(FlagOptions, FLAG_NOPM, &value)) 
 	xf86Info.pmFlag = !value;
@@ -1331,12 +1318,14 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
     }
 
     if (!xf86Info.forceInputDevices && !(foundPointer && foundKeyboard)) {
-#if defined(CONFIG_HAL) || defined(CONFIG_UDEV)
+#if defined(CONFIG_HAL) || defined(CONFIG_UDEV) || defined(CONFIG_WSCONS)
 	const char *config_backend;
 #if defined(CONFIG_HAL)
 	config_backend = "HAL";
-#else
+#elif defined(CONFIG_UDEV)
 	config_backend = "udev";
+#else
+	config_backend = "wscons";
 #endif
 	xf86Msg(X_INFO, "The server relies on %s to provide the list of "
 	                "input devices.\n\tIf no devices become available, "
diff --git a/xorg-server/hw/xfree86/common/xf86Globals.c b/xorg-server/hw/xfree86/common/xf86Globals.c
index 93533ec80..f46799615 100644
--- a/xorg-server/hw/xfree86/common/xf86Globals.c
+++ b/xorg-server/hw/xfree86/common/xf86Globals.c
@@ -96,7 +96,6 @@ InputInfoPtr xf86InputDevs = NULL;
 xf86InfoRec xf86Info = {
     .consoleFd                  = -1,
     .vtno                       = -1,
-    .vtSysreq                   = FALSE,
     .lastEventTime              = -1,
     .vtRequestsPending          = FALSE,
 #ifdef sun
@@ -111,7 +110,6 @@ xf86InfoRec xf86Info = {
     .caughtSignal               = FALSE,
     .currentScreen              = NULL,
 #ifdef CSRG_BASED
-    .screenFd                   = -1,
     .consType                   = -1,
 #endif
     .allowMouseOpenFail         = FALSE,
@@ -125,7 +123,7 @@ xf86InfoRec xf86Info = {
     .log                        = LogNone,
     .disableRandR               = FALSE,
     .randRFrom                  = X_DEFAULT,
-#if defined(CONFIG_HAL) || defined(CONFIG_UDEV)
+#if defined(CONFIG_HAL) || defined(CONFIG_UDEV) || defined(CONFIG_WSCONS)
     .forceInputDevices          = FALSE,
     .autoAddDevices             = TRUE,
     .autoEnableDevices          = TRUE
diff --git a/xorg-server/hw/xfree86/common/xf86Module.h b/xorg-server/hw/xfree86/common/xf86Module.h
index 3038c0404..330d87ae8 100644
--- a/xorg-server/hw/xfree86/common/xf86Module.h
+++ b/xorg-server/hw/xfree86/common/xf86Module.h
@@ -83,7 +83,7 @@ typedef enum {
  */
 #define ABI_ANSIC_VERSION	SET_ABI_VERSION(0, 4)
 #define ABI_VIDEODRV_VERSION	SET_ABI_VERSION(11, 0)
-#define ABI_XINPUT_VERSION	SET_ABI_VERSION(13, 0)
+#define ABI_XINPUT_VERSION	SET_ABI_VERSION(14, 0)
 #define ABI_EXTENSION_VERSION	SET_ABI_VERSION(6, 0)
 #define ABI_FONT_VERSION	SET_ABI_VERSION(0, 6)
 
diff --git a/xorg-server/hw/xfree86/common/xf86Privstr.h b/xorg-server/hw/xfree86/common/xf86Privstr.h
index 14cd56a26..79bc8a084 100644
--- a/xorg-server/hw/xfree86/common/xf86Privstr.h
+++ b/xorg-server/hw/xfree86/common/xf86Privstr.h
@@ -57,7 +57,6 @@ typedef enum {
 typedef struct {
     int			consoleFd;
     int			vtno;
-    Bool		vtSysreq;
 
     /* event handler part */
     int			lastEventTime;
@@ -76,8 +75,6 @@ typedef struct {
     /* graphics part */
     ScreenPtr		currentScreen;
 #if defined(CSRG_BASED) || defined(__FreeBSD_kernel__)
-    int			screenFd;	/* fd for memory mapped access to
-					 * vga card */
     int			consType;	/* Which console driver? */
 #endif
 
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c
index 9fbcba9d5..ea1f92761 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.c
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.c
@@ -936,7 +936,8 @@ NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
 
         if (strcmp(input_option_get_key(option), "_source") == 0 &&
             (strcmp(input_option_get_value(option), "server/hal") == 0 ||
-             strcmp(input_option_get_value(option), "server/udev") == 0)) {
+             strcmp(input_option_get_value(option), "server/udev") == 0 ||
+             strcmp(input_option_get_value(option), "server/wscons") == 0)) {
             is_auto = 1;
             if (!xf86Info.autoAddDevices) {
                 rval = BadMatch;
@@ -1363,15 +1364,15 @@ xf86XInputSetScreen(InputInfoPtr	pInfo,
 }
 
 
-void
+Bool
 xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int maxval,
 			   int resolution, int min_res, int max_res, int mode)
 {
     if (!dev || !dev->valuator)
-        return;
+        return FALSE;
 
-    InitValuatorAxisStruct(dev, axnum, label, minval, maxval, resolution, min_res,
-			   max_res, mode);
+    return InitValuatorAxisStruct(dev, axnum, label, minval, maxval, resolution, min_res,
+				  max_res, mode);
 }
 
 /*
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.h b/xorg-server/hw/xfree86/common/xf86Xinput.h
index a4d9e58a5..189f7abaf 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.h
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.h
@@ -145,7 +145,7 @@ extern _X_EXPORT InputInfoPtr xf86FirstLocalDevice(void);
 extern _X_EXPORT int xf86ScaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min);
 extern _X_EXPORT void xf86XInputSetScreen(InputInfoPtr pInfo, int screen_number, int x, int y);
 extern _X_EXPORT void xf86ProcessCommonOptions(InputInfoPtr pInfo, XF86OptionPtr options);
-extern _X_EXPORT void xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval,
+extern _X_EXPORT Bool xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval,
 				int maxval, int resolution, int min_res,
 				int max_res, int mode);
 extern _X_EXPORT void xf86InitValuatorDefaults(DeviceIntPtr dev, int axnum);
diff --git a/xorg-server/hw/xfree86/doc/ddxDesign.xml b/xorg-server/hw/xfree86/doc/ddxDesign.xml
index bc25c56d8..a4baad557 100644
--- a/xorg-server/hw/xfree86/doc/ddxDesign.xml
+++ b/xorg-server/hw/xfree86/doc/ddxDesign.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
  "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
+ <!ENTITY % xorg-defs SYSTEM "defs.ent"> %xorg-defs;
  <!ENTITY % defs SYSTEM "/xserver/doc/xml/xserver.ent"> %defs;
  <!-- config file keyword markup -->
  <!-- specific config file keywords -->
@@ -19,13 +20,11 @@
 <article id="ddxDesign">
   <articleinfo>
 
-    <title>XFree86 DDX Design (Xorg server version &xserver.version;)</title>
+    <title>XFree86 DDX Design</title>
 
     <authorgroup>
-      <corpauthor><ulink url="http://www.xfree86.org/">
-	The XFree86 Project, Inc.</ulink></corpauthor>
-      <corpauthor><ulink url="http://www.x.org/">
-	The X.Org Foundation, Inc.</ulink></corpauthor>
+      <corpauthor>The XFree86 Project</corpauthor>
+      <corpauthor>The X.Org Foundation</corpauthor>
 
       <othercredit>
 	<firstname>Jim</firstname><surname>Gettys</surname>
@@ -34,6 +33,7 @@
     </authorgroup>
 
     <pubdate>&xserver.reldate;</pubdate>
+    <releaseinfo>X Version 11, Release &fullrelvers;</releaseinfo>
     <releaseinfo>Xorg server version &xserver.version;</releaseinfo>
 
   </articleinfo>
diff --git a/xorg-server/hw/xfree86/man/xorg.conf.man b/xorg-server/hw/xfree86/man/xorg.conf.man
index 62c491cb2..7f98851b6 100644
--- a/xorg-server/hw/xfree86/man/xorg.conf.man
+++ b/xorg-server/hw/xfree86/man/xorg.conf.man
@@ -560,18 +560,6 @@ drivers to not report failure if the mouse device can't be opened/initialised.
 It has no effect on the evdev(__drivermansuffix__) or other drivers.
 Default: false.
 .TP 7
-.BI "Option \*qVTSysReq\*q  \*q" boolean \*q
-enables the SYSV\-style VT switch sequence for non\-SYSV systems
-which support VT switching.
-This sequence is
-.B Alt\-SysRq
-followed by a function key
-.RB ( Fn ).
-This prevents the __xservername__ server trapping the
-keys used for the default VT switch sequence, which means that clients can
-access them.
-Default: off.
-.TP 7
 .BI "Option \*qBlankTime\*q  \*q" time \*q
 sets the inactivity timeout for the
 .B blank
diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.c b/xorg-server/hw/xfree86/modes/xf86Crtc.c
index 1f43ab9a6..3fae039ed 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.c
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.c
@@ -1,3237 +1,3238 @@
-/*

- * Copyright © 2006 Keith Packard

- * Copyright © 2008 Red Hat, Inc.

- *

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

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

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

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

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

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

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

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

- * is" without express or implied warranty.

- *

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

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

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

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

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

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

- * OF THIS SOFTWARE.

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#else

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#endif

-

-#include <stddef.h>

-#include <string.h>

-#include <stdio.h>

-

-#include "xf86.h"

-#include "xf86DDC.h"

-#include "xf86Crtc.h"

-#include "xf86Modes.h"

-#include "xf86Priv.h"

-#include "xf86RandR12.h"

-#include "X11/extensions/render.h"

-#include "X11/extensions/dpmsconst.h"

-#include "X11/Xatom.h"

-#include "picturestr.h"

-

-#include "xf86xv.h"

-

-#define NO_OUTPUT_DEFAULT_WIDTH 1024

-#define NO_OUTPUT_DEFAULT_HEIGHT 768

-/*

- * Initialize xf86CrtcConfig structure

- */

-

-int xf86CrtcConfigPrivateIndex = -1;

-

-void

-xf86CrtcConfigInit (ScrnInfoPtr scrn,

-		    const xf86CrtcConfigFuncsRec *funcs)

-{

-    xf86CrtcConfigPtr	config;

-    

-    if (xf86CrtcConfigPrivateIndex == -1)

-	xf86CrtcConfigPrivateIndex = xf86AllocateScrnInfoPrivateIndex();

-    config = xnfcalloc (1, sizeof (xf86CrtcConfigRec));

-

-    config->funcs = funcs;

-

-    scrn->privates[xf86CrtcConfigPrivateIndex].ptr = config;

-}

- 

-void

-xf86CrtcSetSizeRange (ScrnInfoPtr scrn,

-		      int minWidth, int minHeight,

-		      int maxWidth, int maxHeight)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-

-    config->minWidth = minWidth;

-    config->minHeight = minHeight;

-    config->maxWidth = maxWidth;

-    config->maxHeight = maxHeight;

-}

-

-/*

- * Crtc functions

- */

-xf86CrtcPtr

-xf86CrtcCreate (ScrnInfoPtr		scrn,

-		const xf86CrtcFuncsRec	*funcs)

-{

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    xf86CrtcPtr		crtc, *crtcs;

-

-    crtc = calloc(sizeof (xf86CrtcRec), 1);

-    if (!crtc)

-	return NULL;

-    crtc->version = XF86_CRTC_VERSION;

-    crtc->scrn = scrn;

-    crtc->funcs = funcs;

-#ifdef RANDR_12_INTERFACE

-    crtc->randr_crtc = NULL;

-#endif

-    crtc->rotation = RR_Rotate_0;

-    crtc->desiredRotation = RR_Rotate_0;

-    pixman_transform_init_identity (&crtc->crtc_to_framebuffer);

-    pixman_f_transform_init_identity (&crtc->f_crtc_to_framebuffer);

-    pixman_f_transform_init_identity (&crtc->f_framebuffer_to_crtc);

-    crtc->filter = NULL;

-    crtc->params = NULL;

-    crtc->nparams = 0;

-    crtc->filter_width = 0;

-    crtc->filter_height = 0;

-    crtc->transform_in_use = FALSE;

-    crtc->transformPresent = FALSE;

-    crtc->desiredTransformPresent = FALSE;

-    memset (&crtc->bounds, '\0', sizeof (crtc->bounds));

-

-    /* Preallocate gamma at a sensible size. */

-    crtc->gamma_size = 256;

-    crtc->gamma_red = malloc(3 * crtc->gamma_size * sizeof (CARD16));

-    if (!crtc->gamma_red) {

-	free(crtc);

-	return NULL;

-    }

-    crtc->gamma_green = crtc->gamma_red + crtc->gamma_size;

-    crtc->gamma_blue = crtc->gamma_green + crtc->gamma_size;

-

-    if (xf86_config->crtc)

-	crtcs = realloc(xf86_config->crtc,

-			  (xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));

-    else

-	crtcs = malloc((xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));

-    if (!crtcs)

-    {

-	free(crtc);

-	return NULL;

-    }

-    xf86_config->crtc = crtcs;

-    xf86_config->crtc[xf86_config->num_crtc++] = crtc;

-    return crtc;

-}

-

-void

-xf86CrtcDestroy (xf86CrtcPtr crtc)

-{

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);

-    int			c;

-    

-    (*crtc->funcs->destroy) (crtc);

-    for (c = 0; c < xf86_config->num_crtc; c++)

-	if (xf86_config->crtc[c] == crtc)

-	{

-	    memmove (&xf86_config->crtc[c],

-		     &xf86_config->crtc[c+1],

-		     ((xf86_config->num_crtc - (c + 1)) * sizeof(void*)));

-	    xf86_config->num_crtc--;

-	    break;

-	}

-    free(crtc->params);

-    free(crtc->gamma_red);

-    free(crtc);

-}

-

-

-/**

- * Return whether any outputs are connected to the specified pipe

- */

-

-Bool

-xf86CrtcInUse (xf86CrtcPtr crtc)

-{

-    ScrnInfoPtr		pScrn = crtc->scrn;

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);

-    int			o;

-    

-    for (o = 0; o < xf86_config->num_output; o++)

-	if (xf86_config->output[o]->crtc == crtc)

-	    return TRUE;

-    return FALSE;

-}

-

-void

-xf86CrtcSetScreenSubpixelOrder (ScreenPtr pScreen)

-{

-    int			subpixel_order = SubPixelUnknown;

-    Bool		has_none = FALSE;

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

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			c, o;

-

-    for (c = 0; c < xf86_config->num_crtc; c++)

-    {

-	xf86CrtcPtr crtc = xf86_config->crtc[c];

-	

-	for (o = 0; o < xf86_config->num_output; o++)

-	{

-	    xf86OutputPtr   output = xf86_config->output[o];

-

-	    if (output->crtc == crtc)

-	    {

-		switch (output->subpixel_order) {

-		case SubPixelNone:

-		    has_none = TRUE;

-		    break;

-		case SubPixelUnknown:

-		    break;

-		default:

-		    subpixel_order = output->subpixel_order;

-		    break;

-		}

-	    }

-	    if (subpixel_order != SubPixelUnknown)

-		break;

-	}

-	if (subpixel_order != SubPixelUnknown)

-	{

-	    static const int circle[4] = {

-		SubPixelHorizontalRGB,

-		SubPixelVerticalRGB,

-		SubPixelHorizontalBGR,

-		SubPixelVerticalBGR,

-	    };

-	    int	rotate;

-	    int c;

-	    for (rotate = 0; rotate < 4; rotate++)

-		if (crtc->rotation & (1 << rotate))

-		    break;

-	    for (c = 0; c < 4; c++)

-		if (circle[c] == subpixel_order)

-		    break;

-	    c = (c + rotate) & 0x3;

-	    if ((crtc->rotation & RR_Reflect_X) && !(c & 1))

-		c ^= 2;

-	    if ((crtc->rotation & RR_Reflect_Y) && (c & 1))

-		c ^= 2;

-	    subpixel_order = circle[c];

-	    break;

-	}

-    }

-    if (subpixel_order == SubPixelUnknown && has_none)

-	subpixel_order = SubPixelNone;

-    PictureSetSubpixelOrder (pScreen, subpixel_order);

-}

-

-/**

- * Sets the given video mode on the given crtc

- */

-Bool

-xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,

-			  RRTransformPtr transform, int x, int y)

-{

-    ScrnInfoPtr		scrn = crtc->scrn;

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			i;

-    Bool		ret = FALSE;

-    Bool		didLock = FALSE;

-    DisplayModePtr	adjusted_mode;

-    DisplayModeRec	saved_mode;

-    int			saved_x, saved_y;

-    Rotation		saved_rotation;

-    RRTransformRec	saved_transform;

-    Bool		saved_transform_present;

-

-    crtc->enabled = xf86CrtcInUse (crtc);

-

-    /* We only hit this if someone explicitly sends a "disabled" modeset. */

-    if (!crtc->enabled)

-    {

-	/* Check everything for stuff that should be off. */

-	xf86DisableUnusedFunctions(scrn);

-	return TRUE;

-    }

-

-    adjusted_mode = xf86DuplicateMode(mode);

-

-

-    saved_mode = crtc->mode;

-    saved_x = crtc->x;

-    saved_y = crtc->y;

-    saved_rotation = crtc->rotation;

-    if (crtc->transformPresent) {

-	RRTransformInit (&saved_transform);

-	RRTransformCopy (&saved_transform, &crtc->transform);

-    }

-    saved_transform_present = crtc->transformPresent;

-

-    /* Update crtc values up front so the driver can rely on them for mode

-     * setting.

-     */

-    crtc->mode = *mode;

-    crtc->x = x;

-    crtc->y = y;

-    crtc->rotation = rotation;

-    if (transform) {

-	RRTransformCopy (&crtc->transform, transform);

-	crtc->transformPresent = TRUE;

-    } else

-	crtc->transformPresent = FALSE;

-

-    if (crtc->funcs->set_mode_major) {

-	ret = crtc->funcs->set_mode_major(crtc, mode, rotation, x, y);

-	goto done;

-    }

-

-    didLock = crtc->funcs->lock (crtc);

-    /* Pass our mode to the outputs and the CRTC to give them a chance to

-     * adjust it according to limitations or output properties, and also

-     * a chance to reject the mode entirely.

-     */

-    for (i = 0; i < xf86_config->num_output; i++) {

-	xf86OutputPtr output = xf86_config->output[i];

-

-	if (output->crtc != crtc)

-	    continue;

-

-	if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {

-	    goto done;

-	}

-    }

-

-    if (!crtc->funcs->mode_fixup(crtc, mode, adjusted_mode)) {

-	goto done;

-    }

-

-    if (!xf86CrtcRotate (crtc))

-	goto done;

-

-    /* Prepare the outputs and CRTCs before setting the mode. */

-    for (i = 0; i < xf86_config->num_output; i++) {

-	xf86OutputPtr output = xf86_config->output[i];

-

-	if (output->crtc != crtc)

-	    continue;

-

-	/* Disable the output as the first thing we do. */

-	output->funcs->prepare(output);

-    }

-

-    crtc->funcs->prepare(crtc);

-

-    /* Set up the DPLL and any output state that needs to adjust or depend

-     * on the DPLL.

-     */

-    crtc->funcs->mode_set(crtc, mode, adjusted_mode, crtc->x, crtc->y);

-    for (i = 0; i < xf86_config->num_output; i++) 

-    {

-	xf86OutputPtr output = xf86_config->output[i];

-	if (output->crtc == crtc)

-	    output->funcs->mode_set(output, mode, adjusted_mode);

-    }

-

-    /* Only upload when needed, to avoid unneeded delays. */

-    if (!crtc->active && crtc->funcs->gamma_set)

-	crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,

-                                            crtc->gamma_blue, crtc->gamma_size);

-

-    /* Now, enable the clocks, plane, pipe, and outputs that we set up. */

-    crtc->funcs->commit(crtc);

-    for (i = 0; i < xf86_config->num_output; i++) 

-    {

-	xf86OutputPtr output = xf86_config->output[i];

-	if (output->crtc == crtc)

-	    output->funcs->commit(output);

-    }

-

-    ret = TRUE;

-

-done:

-    if (ret) {

-	crtc->active = TRUE;

-	if (scrn->pScreen)

-	    xf86CrtcSetScreenSubpixelOrder (scrn->pScreen);

-	if (scrn->ModeSet)

-	    scrn->ModeSet(scrn);

-    } else {

-	crtc->x = saved_x;

-	crtc->y = saved_y;

-	crtc->rotation = saved_rotation;

-	crtc->mode = saved_mode;

-	if (saved_transform_present)

-	    RRTransformCopy (&crtc->transform, &saved_transform);

-	crtc->transformPresent = saved_transform_present;

-    }

-

-    free(adjusted_mode->name);

-    free(adjusted_mode);

-

-    if (didLock)

-	crtc->funcs->unlock (crtc);

-

-    return ret;

-}

-

-/**

- * Sets the given video mode on the given crtc, but without providing

- * a transform

- */

-Bool

-xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,

-		 int x, int y)

-{

-    return xf86CrtcSetModeTransform (crtc, mode, rotation, NULL, x, y);

-}

-

-/**

- * Pans the screen, does not change the mode

- */

-void

-xf86CrtcSetOrigin (xf86CrtcPtr crtc, int x, int y)

-{

-    ScrnInfoPtr scrn = crtc->scrn;

-

-    crtc->x = x;

-    crtc->y = y;

-    if (crtc->funcs->set_origin) {

-	if (!xf86CrtcRotate (crtc))

-	    return;

-	crtc->funcs->set_origin (crtc, x, y);

-	if (scrn->ModeSet)

-	    scrn->ModeSet(scrn);

-    }

-    else

-	xf86CrtcSetMode (crtc, &crtc->mode, crtc->rotation, x, y);

-}

-

-/*

- * Output functions

- */

-

-extern XF86ConfigPtr xf86configptr;

-

-typedef enum {

-    OPTION_PREFERRED_MODE,

-    OPTION_POSITION,

-    OPTION_BELOW,

-    OPTION_RIGHT_OF,

-    OPTION_ABOVE,

-    OPTION_LEFT_OF,

-    OPTION_ENABLE,

-    OPTION_DISABLE,

-    OPTION_MIN_CLOCK,

-    OPTION_MAX_CLOCK,

-    OPTION_IGNORE,

-    OPTION_ROTATE,

-    OPTION_PANNING,

-    OPTION_PRIMARY,

-    OPTION_DEFAULT_MODES,

-} OutputOpts;

-

-static OptionInfoRec xf86OutputOptions[] = {

-    {OPTION_PREFERRED_MODE, "PreferredMode",	OPTV_STRING,  {0}, FALSE },

-    {OPTION_POSITION,	    "Position",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_BELOW,	    "Below",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_RIGHT_OF,	    "RightOf",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_ABOVE,	    "Above",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_LEFT_OF,	    "LeftOf",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_ENABLE,	    "Enable",		OPTV_BOOLEAN, {0}, FALSE },

-    {OPTION_DISABLE,	    "Disable",		OPTV_BOOLEAN, {0}, FALSE },

-    {OPTION_MIN_CLOCK,	    "MinClock",		OPTV_FREQ,    {0}, FALSE },

-    {OPTION_MAX_CLOCK,	    "MaxClock",		OPTV_FREQ,    {0}, FALSE },

-    {OPTION_IGNORE,	    "Ignore",		OPTV_BOOLEAN, {0}, FALSE },

-    {OPTION_ROTATE,	    "Rotate",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_PANNING,	    "Panning",		OPTV_STRING,  {0}, FALSE },

-    {OPTION_PRIMARY,	    "Primary",		OPTV_BOOLEAN, {0}, FALSE },

-    {OPTION_DEFAULT_MODES,  "DefaultModes",	OPTV_BOOLEAN, {0}, FALSE },

-    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },

-};

-

-enum {

-    OPTION_MODEDEBUG,

-};

-

-static OptionInfoRec xf86DeviceOptions[] = {

-    {OPTION_MODEDEBUG,	    "ModeDebug",	OPTV_BOOLEAN,  {0}, FALSE },

-    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },

-};

-

-static void

-xf86OutputSetMonitor (xf86OutputPtr output)

-{

-    char    *option_name;

-    char    *monitor;

-

-    if (!output->name)

-	return;

-

-    free(output->options);

-

-    output->options = xnfalloc (sizeof (xf86OutputOptions));

-    memcpy (output->options, xf86OutputOptions, sizeof (xf86OutputOptions));

-

-    XNFasprintf(&option_name, "monitor-%s", output->name);

-    monitor = xf86findOptionValue (output->scrn->options, option_name);

-    if (!monitor)

-	monitor = output->name;

-    else

-	xf86MarkOptionUsedByName (output->scrn->options, option_name);

-    free(option_name);

-    output->conf_monitor = xf86findMonitor (monitor,

-					    xf86configptr->conf_monitor_lst);

-    /*

-     * Find the monitor section of the screen and use that

-     */

-    if (!output->conf_monitor && output->use_screen_monitor)

-	output->conf_monitor = xf86findMonitor (output->scrn->monitor->id,

-						xf86configptr->conf_monitor_lst);

-    if (output->conf_monitor)

-    {

-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,

-		    "Output %s using monitor section %s\n",

-		    output->name, output->conf_monitor->mon_identifier);

-	xf86ProcessOptions (output->scrn->scrnIndex,

-			    output->conf_monitor->mon_option_lst,

-			    output->options);

-    }

-    else

-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,

-		    "Output %s has no monitor section\n",

-		    output->name);

-}

-

-static Bool

-xf86OutputEnabled (xf86OutputPtr output, Bool strict)

-{

-    Bool    enable, disable;

-

-    /* check to see if this output was enabled in the config file */

-    if (xf86GetOptValBool (output->options, OPTION_ENABLE, &enable) && enable)

-    {

-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,

-		    "Output %s enabled by config file\n", output->name);

-	return TRUE;

-    }

-    /* or if this output was disabled in the config file */

-    if (xf86GetOptValBool (output->options, OPTION_DISABLE, &disable) && disable)

-    {

-	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,

-		    "Output %s disabled by config file\n", output->name);

-	return FALSE;

-    }

-

-    /* If not, try to only light up the ones we know are connected */

-    if (strict) {

-	enable = output->status == XF86OutputStatusConnected;

-    }

-    /* But if that fails, try to light up even outputs we're unsure of */

-    else {

-	enable = output->status != XF86OutputStatusDisconnected;

-    }

-

-    xf86DrvMsg (output->scrn->scrnIndex, X_INFO,

-    	    "Output %s %sconnected\n", output->name, enable ? "" : "dis");

-    return enable;

-}

-

-static Bool

-xf86OutputIgnored (xf86OutputPtr    output)

-{

-    return xf86ReturnOptValBool (output->options, OPTION_IGNORE, FALSE);

-}

-

-static char *direction[4] = {

-    "normal", 

-    "left", 

-    "inverted", 

-    "right"

-};

-

-static Rotation

-xf86OutputInitialRotation (xf86OutputPtr output)

-{

-    char    *rotate_name = xf86GetOptValString (output->options, 

-						OPTION_ROTATE);

-    int	    i;

-

-    if (!rotate_name) {

-	if (output->initial_rotation)

-	    return output->initial_rotation;

-	return RR_Rotate_0;

-    }

-    

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

-	if (xf86nameCompare (direction[i], rotate_name) == 0)

-	    return 1 << i;

-    return RR_Rotate_0;

-}

-

-xf86OutputPtr

-xf86OutputCreate (ScrnInfoPtr		    scrn,

-		  const xf86OutputFuncsRec  *funcs,

-		  const char		    *name)

-{

-    xf86OutputPtr	output, *outputs;

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			len;

-    Bool		primary;

-

-    if (name)

-	len = strlen (name) + 1;

-    else

-	len = 0;

-

-    output = calloc(sizeof (xf86OutputRec) + len, 1);

-    if (!output)

-	return NULL;

-    output->scrn = scrn;

-    output->funcs = funcs;

-    if (name)

-    {

-	output->name = (char *) (output + 1);

-	strcpy (output->name, name);

-    }

-    output->subpixel_order = SubPixelUnknown;

-    /*

-     * Use the old per-screen monitor section for the first output

-     */

-    output->use_screen_monitor = (xf86_config->num_output == 0);

-#ifdef RANDR_12_INTERFACE

-    output->randr_output = NULL;

-#endif

-    if (name)

-    {

-	xf86OutputSetMonitor (output);

-	if (xf86OutputIgnored (output))

-	{

-	    free(output);

-	    return FALSE;

-	}

-    }

-    

-    

-    if (xf86_config->output)

-	outputs = realloc(xf86_config->output,

-			  (xf86_config->num_output + 1) * sizeof (xf86OutputPtr));

-    else

-	outputs = malloc((xf86_config->num_output + 1) * sizeof (xf86OutputPtr));

-    if (!outputs)

-    {

-	free(output);

-	return NULL;

-    }

-

-    xf86_config->output = outputs;

-

-    if (xf86GetOptValBool (output->options, OPTION_PRIMARY, &primary) && primary)

-    {

-	memmove(xf86_config->output + 1, xf86_config->output,

-		xf86_config->num_output * sizeof (xf86OutputPtr));

-	xf86_config->output[0] = output;

-    }

-    else

-    {

-	xf86_config->output[xf86_config->num_output] = output;

-    }

-

-    xf86_config->num_output++;

-

-    return output;

-}

-

-Bool

-xf86OutputRename (xf86OutputPtr output, const char *name)

-{

-    char    *newname = strdup(name);

-    

-    if (!newname)

-	return FALSE;	/* so sorry... */

-    

-    if (output->name && output->name != (char *) (output + 1))

-	free(output->name);

-    output->name = newname;

-    xf86OutputSetMonitor (output);

-    if (xf86OutputIgnored (output))

-	return FALSE;

-    return TRUE;

-}

-

-void

-xf86OutputUseScreenMonitor (xf86OutputPtr output, Bool use_screen_monitor)

-{

-    if (use_screen_monitor != output->use_screen_monitor)

-    {

-	output->use_screen_monitor = use_screen_monitor;

-	xf86OutputSetMonitor (output);

-    }

-}

-

-void

-xf86OutputDestroy (xf86OutputPtr output)

-{

-    ScrnInfoPtr		scrn = output->scrn;

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o;

-    

-    (*output->funcs->destroy) (output);

-    while (output->probed_modes)

-	xf86DeleteMode (&output->probed_modes, output->probed_modes);

-    for (o = 0; o < xf86_config->num_output; o++)

-	if (xf86_config->output[o] == output)

-	{

-	    memmove (&xf86_config->output[o],

-		     &xf86_config->output[o+1],

-		     ((xf86_config->num_output - (o + 1)) * sizeof(void*)));

-	    xf86_config->num_output--;

-	    break;

-	}

-    if (output->name && output->name != (char *) (output + 1))

-	free(output->name);

-    free(output);

-}

-

-/*

- * Called during CreateScreenResources to hook up RandR

- */

-static Bool

-xf86CrtcCreateScreenResources (ScreenPtr screen)

-{

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

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-

-    screen->CreateScreenResources = config->CreateScreenResources;

-    

-    if (!(*screen->CreateScreenResources)(screen))

-	return FALSE;

-

-    if (!xf86RandR12CreateScreenResources (screen))

-	return FALSE;

-

-    return TRUE;

-}

-

-/*

- * Clean up config on server reset

- */

-static Bool

-xf86CrtcCloseScreen (int index, ScreenPtr screen)

-{

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

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o, c;

-    

-    screen->CloseScreen = config->CloseScreen;

-

-    xf86RotateCloseScreen (screen);

-

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-

-	output->randr_output = NULL;

-    }

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	xf86CrtcPtr	crtc = config->crtc[c];

-

-	crtc->randr_crtc = NULL;

-    }

-    xf86RandR12CloseScreen (screen);

-

-    return screen->CloseScreen (index, screen);

-}

-

-/*

- * Called at ScreenInit time to set up

- */

-#ifdef RANDR_13_INTERFACE

-int

-#else

-Bool

-#endif

-xf86CrtcScreenInit (ScreenPtr screen)

-{

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

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			c;

-

-    /* Rotation */

-    xf86DrvMsg(scrn->scrnIndex, X_INFO, "RandR 1.2 enabled, ignore the following RandR disabled message.\n");

-    xf86DisableRandR(); /* Disable old RandR extension support */

-    xf86RandR12Init (screen);

-

-    /* support all rotations if every crtc has the shadow alloc funcs */

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	xf86CrtcPtr crtc = config->crtc[c];

-	if (!crtc->funcs->shadow_allocate || !crtc->funcs->shadow_create)

-	    break;

-    }

-    if (c == config->num_crtc)

-    {

-	xf86RandR12SetRotations (screen, RR_Rotate_0 | RR_Rotate_90 |

-				 RR_Rotate_180 | RR_Rotate_270 |

-				 RR_Reflect_X | RR_Reflect_Y);

-	xf86RandR12SetTransformSupport (screen, TRUE);

-    }

-    else

-    {

-	xf86RandR12SetRotations (screen, RR_Rotate_0);

-	xf86RandR12SetTransformSupport (screen, FALSE);

-    }

-    

-    /* Wrap CreateScreenResources so we can initialize the RandR code */

-    config->CreateScreenResources = screen->CreateScreenResources;

-    screen->CreateScreenResources = xf86CrtcCreateScreenResources;

-

-    config->CloseScreen = screen->CloseScreen;

-    screen->CloseScreen = xf86CrtcCloseScreen;

-    

-#ifdef XFreeXDGA

-    _xf86_di_dga_init_internal(screen);

-#endif

-#ifdef RANDR_13_INTERFACE

-    return RANDR_INTERFACE_VERSION;

-#else

-    return TRUE;

-#endif

-}

-

-static DisplayModePtr

-xf86DefaultMode (xf86OutputPtr output, int width, int height)

-{

-    DisplayModePtr  target_mode = NULL;

-    DisplayModePtr  mode;

-    int		    target_diff = 0;

-    int		    target_preferred = 0;

-    int		    mm_height;

-    

-    mm_height = output->mm_height;

-    if (!mm_height)

-	mm_height = (768 * 25.4) / DEFAULT_DPI;

-    /*

-     * Pick a mode closest to DEFAULT_DPI

-     */

-    for (mode = output->probed_modes; mode; mode = mode->next)

-    {

-	int	    dpi;

-	int	    preferred = (((mode->type & M_T_PREFERRED) != 0) +

-				 ((mode->type & M_T_USERPREF) != 0));

-	int	    diff;

-

-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||

-	    xf86ModeHeight (mode, output->initial_rotation) > height)

-	    continue;

-	

-	/* yes, use VDisplay here, not xf86ModeHeight */

-	dpi = (mode->VDisplay * 254) / (mm_height * 10);

-	diff = dpi - DEFAULT_DPI;

-	diff = diff < 0 ? -diff : diff;

-	if (target_mode == NULL || (preferred > target_preferred) ||

-	    (preferred == target_preferred && diff < target_diff))

-	{

-	    target_mode = mode;

-	    target_diff = diff;

-	    target_preferred = preferred;

-	}

-    }

-    return target_mode;

-}

-

-static DisplayModePtr

-xf86ClosestMode (xf86OutputPtr output, 

-		 DisplayModePtr match, Rotation match_rotation,

-		 int width, int height)

-{

-    DisplayModePtr  target_mode = NULL;

-    DisplayModePtr  mode;

-    int		    target_diff = 0;

-    

-    /*

-     * Pick a mode closest to the specified mode

-     */

-    for (mode = output->probed_modes; mode; mode = mode->next)

-    {

-	int	    dx, dy;

-	int	    diff;

-

-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||

-	    xf86ModeHeight (mode, output->initial_rotation) > height)

-	    continue;

-	

-	/* exact matches are preferred */

-	if (output->initial_rotation == match_rotation &&

-	    xf86ModesEqual (mode, match))

-	    return mode;

-	

-	dx = xf86ModeWidth (match, match_rotation) - xf86ModeWidth (mode, output->initial_rotation);

-	dy = xf86ModeHeight (match, match_rotation) - xf86ModeHeight (mode, output->initial_rotation);

-	diff = dx * dx + dy * dy;

-	if (target_mode == NULL || diff < target_diff)

-	{

-	    target_mode = mode;

-	    target_diff = diff;

-	}

-    }

-    return target_mode;

-}

-

-static DisplayModePtr

-xf86OutputHasPreferredMode (xf86OutputPtr output, int width, int height)

-{

-    DisplayModePtr  mode;

-

-    for (mode = output->probed_modes; mode; mode = mode->next)

-    {

-	if (xf86ModeWidth (mode, output->initial_rotation) > width ||

-	    xf86ModeHeight (mode, output->initial_rotation) > height)

-	    continue;

-

-	if (mode->type & M_T_PREFERRED)

-	    return mode;

-    }

-    return NULL;

-}

-

-static DisplayModePtr

-xf86OutputHasUserPreferredMode (xf86OutputPtr output)

-{

-    DisplayModePtr mode, first = output->probed_modes;

-

-    for (mode = first; mode && mode->next != first; mode = mode->next)

-	if (mode->type & M_T_USERPREF)

-	    return mode;

-

-    return NULL;

-}

-

-static int

-xf86PickCrtcs (ScrnInfoPtr	scrn,

-	       xf86CrtcPtr	*best_crtcs,

-	       DisplayModePtr	*modes,

-	       int		n,

-	       int		width,

-	       int		height)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int		    c, o;

-    xf86OutputPtr   output;

-    xf86CrtcPtr	    crtc;

-    xf86CrtcPtr	    *crtcs;

-    xf86CrtcPtr	    best_crtc;

-    int		    best_score;

-    int		    score;

-    int		    my_score;

-    

-    if (n == config->num_output)

-	return 0;

-    output = config->output[n];

-    

-    /*

-     * Compute score with this output disabled

-     */

-    best_crtcs[n] = NULL;

-    best_crtc = NULL;

-    best_score = xf86PickCrtcs (scrn, best_crtcs, modes, n+1, width, height);

-    if (modes[n] == NULL)

-	return best_score;

-    

-    crtcs = malloc(config->num_output * sizeof (xf86CrtcPtr));

-    if (!crtcs)

-	return best_score;

-

-    my_score = 1;

-    /* Score outputs that are known to be connected higher */

-    if (output->status == XF86OutputStatusConnected)

-	my_score++;

-    /* Score outputs with preferred modes higher */

-    if (xf86OutputHasPreferredMode (output, width, height))

-	my_score++;

-    /*

-     * Select a crtc for this output and

-     * then attempt to configure the remaining

-     * outputs

-     */

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	if ((output->possible_crtcs & (1 << c)) == 0)

-	    continue;

-	

-	crtc = config->crtc[c];

-	/*

-	 * Check to see if some other output is

-	 * using this crtc

-	 */

-	for (o = 0; o < n; o++)

-	    if (best_crtcs[o] == crtc)

-		break;

-	if (o < n)

-	{

-	    /*

-	     * If the two outputs desire the same mode,

-	     * see if they can be cloned

-	     */

-	    if (xf86ModesEqual (modes[o], modes[n]) &&

-		config->output[o]->initial_rotation == config->output[n]->initial_rotation &&

-		config->output[o]->initial_x == config->output[n]->initial_x &&

-		config->output[o]->initial_y == config->output[n]->initial_y)

-	    {

-		if ((output->possible_clones & (1 << o)) == 0)

-		    continue;		/* nope, try next CRTC */

-	    }

-	    else

-		continue;		/* different modes, can't clone */

-	}

-	crtcs[n] = crtc;

-	memcpy (crtcs, best_crtcs, n * sizeof (xf86CrtcPtr));

-	score = my_score + xf86PickCrtcs (scrn, crtcs, modes, n+1, width, height);

-	if (score > best_score)

-	{

-	    best_crtc = crtc;

-	    best_score = score;

-	    memcpy (best_crtcs, crtcs, config->num_output * sizeof (xf86CrtcPtr));

-	}

-    }

-    free(crtcs);

-    return best_score;

-}

-

-

-/*

- * Compute the virtual size necessary to place all of the available

- * crtcs in the specified configuration.

- *

- * canGrow indicates that the driver can make the screen larger than its initial

- * configuration.  If FALSE, this function will enlarge the screen to include

- * the largest available mode.

- */

-

-static void

-xf86DefaultScreenLimits (ScrnInfoPtr scrn, int *widthp, int *heightp,

-			 Bool canGrow)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int	    width = 0, height = 0;

-    int	    o;

-    int	    c;

-    int	    s;

-

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	int	    crtc_width = 0, crtc_height = 0;

-	xf86CrtcPtr crtc = config->crtc[c];

-

-	if (crtc->enabled)

-	{

-	    crtc_width = crtc->desiredX + xf86ModeWidth (&crtc->desiredMode, crtc->desiredRotation);

-	    crtc_height = crtc->desiredY + xf86ModeHeight (&crtc->desiredMode, crtc->desiredRotation);

-	}

-	if (!canGrow) {

-	    for (o = 0; o < config->num_output; o++)

-	    {

-		xf86OutputPtr   output = config->output[o];

-

-		for (s = 0; s < config->num_crtc; s++)

-		    if (output->possible_crtcs & (1 << s))

-		    {

-			DisplayModePtr  mode;

-			for (mode = output->probed_modes; mode; mode = mode->next)

-			{

-			    if (mode->HDisplay > crtc_width)

-				crtc_width = mode->HDisplay;

-			    if (mode->VDisplay > crtc_width)

-				crtc_width = mode->VDisplay;

-			    if (mode->VDisplay > crtc_height)

-				crtc_height = mode->VDisplay;

-			    if (mode->HDisplay > crtc_height)

-				crtc_height = mode->HDisplay;

-			}

-		    }

-	    }

-	}

-	if (crtc_width > width)

-	    width = crtc_width;

-	if (crtc_height > height)

-	    height = crtc_height;

-    }

-    if (config->maxWidth && width > config->maxWidth) width = config->maxWidth;

-    if (config->maxHeight && height > config->maxHeight) height = config->maxHeight;

-    if (config->minWidth && width < config->minWidth) width = config->minWidth;

-    if (config->minHeight && height < config->minHeight) height = config->minHeight;

-    *widthp = width;

-    *heightp = height;

-}

-

-#define POSITION_UNSET	-100000

-

-/*

- * check if the user configured any outputs at all 

- * with either a position or a relative setting or a mode.

- */

-static Bool

-xf86UserConfiguredOutputs(ScrnInfoPtr scrn, DisplayModePtr *modes)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int o;

-    Bool user_conf = FALSE;

-

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr output = config->output[o];

-	char	    *position;

-	char	    *relative_name;

-	OutputOpts	    relation;

-	int r;

-	static const OutputOpts	relations[] = {

-	    OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF

-	};

-

-	position = xf86GetOptValString (output->options,

-					OPTION_POSITION);

-	if (position)

-	    user_conf = TRUE;

-

-	relation = 0;

-	relative_name = NULL;

-	for (r = 0; r < 4; r++)

-	{

-	    relation = relations[r];

-	    relative_name = xf86GetOptValString (output->options,

-						     relation);

-	    if (relative_name)

-		break;

-	}

-	if (relative_name)

-	    user_conf = TRUE;

-

-	modes[o] = xf86OutputHasUserPreferredMode(output);

-	if (modes[o])

-	    user_conf = TRUE;

-    }

-

-    return user_conf;

-}

-

-static Bool

-xf86InitialOutputPositions (ScrnInfoPtr scrn, DisplayModePtr *modes)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o;

-    int			min_x, min_y;

-    

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-

-	output->initial_x = output->initial_y = POSITION_UNSET;

-    }

-    

-    /*

-     * Loop until all outputs are set

-     */

-    for (;;)

-    {

-	Bool	any_set = FALSE;

-	Bool	keep_going = FALSE;

-

-	for (o = 0; o < config->num_output; o++)	

-	{

-	    static const OutputOpts	relations[] = {

-		OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF

-	    };

-	    xf86OutputPtr   output = config->output[o];

-	    xf86OutputPtr   relative;

-	    char	    *relative_name;

-	    char	    *position;

-	    OutputOpts	    relation;

-	    int		    r;

-

-	    if (output->initial_x != POSITION_UNSET)

-		continue;

-	    position = xf86GetOptValString (output->options,

-					    OPTION_POSITION);

-	    /*

-	     * Absolute position wins

-	     */

-	    if (position)

-	    {

-		int		    x, y;

-		if (sscanf (position, "%d %d", &x, &y) == 2)

-		{

-		    output->initial_x = x;

-		    output->initial_y = y;

-		}

-		else

-		{

-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-				"Output %s position not of form \"x y\"\n",

-				output->name);

-		    output->initial_x = output->initial_y = 0;

-		}

-		any_set = TRUE;

-		continue;

-	    }

-	    /*

-	     * Next comes relative positions

-	     */

-	    relation = 0;

-	    relative_name = NULL;

-	    for (r = 0; r < 4; r++)

-	    {

-		relation = relations[r];

-		relative_name = xf86GetOptValString (output->options,

-						     relation);

-		if (relative_name)

-		    break;

-	    }

-	    if (relative_name)

-	    {

-		int or;

-		relative = NULL;

-		for (or = 0; or < config->num_output; or++)

-		{

-		    xf86OutputPtr	out_rel = config->output[or];

-		    XF86ConfMonitorPtr	rel_mon = out_rel->conf_monitor;

-

-		    if (rel_mon)

-		    {

-			if (xf86nameCompare (rel_mon->mon_identifier,

-					      relative_name) == 0)

-			{

-			    relative = config->output[or];

-			    break;

-			}

-		    }

-		    if (strcmp (out_rel->name, relative_name) == 0)

-		    {

-			relative = config->output[or];

-			break;

-		    }

-		}

-		if (!relative)

-		{

-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-				"Cannot position output %s relative to unknown output %s\n",

-				output->name, relative_name);

-		    output->initial_x = 0;

-		    output->initial_y = 0;

-		    any_set = TRUE;

-		    continue;

-		}

-		if (!modes[or])

-		{

-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-				"Cannot position output %s relative to output %s without modes\n",

-				output->name, relative_name);

-		    output->initial_x = 0;

-		    output->initial_y = 0;

-		    any_set = TRUE;

-		    continue;

-		}

-		if (relative->initial_x == POSITION_UNSET)

-		{

-		    keep_going = TRUE;

-		    continue;

-		}

-		output->initial_x = relative->initial_x;

-		output->initial_y = relative->initial_y;

-		switch (relation) {

-		case OPTION_BELOW:

-		    output->initial_y += xf86ModeHeight (modes[or], relative->initial_rotation);

-		    break;

-		case OPTION_RIGHT_OF:

-		    output->initial_x += xf86ModeWidth (modes[or], relative->initial_rotation);

-		    break;

-		case OPTION_ABOVE:

-		    if (modes[o])

-			output->initial_y -= xf86ModeHeight (modes[o], output->initial_rotation);

-		    break;

-		case OPTION_LEFT_OF:

-		    if (modes[o])

-			output->initial_x -= xf86ModeWidth (modes[o], output->initial_rotation);

-		    break;

-		default:

-		    break;

-		}

-		any_set = TRUE;

-		continue;

-	    }

-	    

-	    /* Nothing set, just stick them at 0,0 */

-	    output->initial_x = 0;

-	    output->initial_y = 0;

-	    any_set = TRUE;

-	}

-	if (!keep_going)

-	    break;

-	if (!any_set) 

-	{

-	    for (o = 0; o < config->num_output; o++)

-	    {

-		xf86OutputPtr   output = config->output[o];

-		if (output->initial_x == POSITION_UNSET)

-		{

-		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-				"Output position loop. Moving %s to 0,0\n",

-				output->name);

-		    output->initial_x = output->initial_y = 0;

-		    break;

-		}

-	    }

-	}

-    }

-

-    /*

-     * normalize positions

-     */

-    min_x = 1000000;

-    min_y = 1000000;

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-

-	if (output->initial_x < min_x)

-	    min_x = output->initial_x;

-	if (output->initial_y < min_y)

-	    min_y = output->initial_y;

-    }

-    

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-

-	output->initial_x -= min_x;

-	output->initial_y -= min_y;

-    }

-    return TRUE;

-}

-

-static void

-xf86InitialPanning (ScrnInfoPtr scrn)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o;

-    

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-	char	       *panning = xf86GetOptValString (output->options, OPTION_PANNING);

-	int		width, height, left, top;

-	int		track_width, track_height, track_left, track_top;

-	int		brdr[4];

-

-	memset (&output->initialTotalArea,    0, sizeof(BoxRec));

-	memset (&output->initialTrackingArea, 0, sizeof(BoxRec));

-	memset (output->initialBorder,        0, 4*sizeof(INT16));

-

-	if (! panning)

-	    continue;

-

-	switch (sscanf (panning, "%dx%d+%d+%d/%dx%d+%d+%d/%d/%d/%d/%d",

-			&width, &height, &left, &top,

-			&track_width, &track_height, &track_left, &track_top,

-			&brdr[0], &brdr[1], &brdr[2], &brdr[3])) {

-	case 12:

-	    output->initialBorder[0] = brdr[0];

-	    output->initialBorder[1] = brdr[1];

-	    output->initialBorder[2] = brdr[2];

-	    output->initialBorder[3] = brdr[3];

-	    /* fall through */

-	case 8:

-	    output->initialTrackingArea.x1 = track_left;

-	    output->initialTrackingArea.y1 = track_top;

-	    output->initialTrackingArea.x2 = track_left + track_width;

-	    output->initialTrackingArea.y2 = track_top  + track_height;

-	    /* fall through */

-	case 4:

-	    output->initialTotalArea.x1 = left;

-	    output->initialTotalArea.y1 = top;

-	    /* fall through */

-	case 2:

-	    output->initialTotalArea.x2 = output->initialTotalArea.x1 + width;

-	    output->initialTotalArea.y2 = output->initialTotalArea.y1 + height;

-	    break;

-	default:

-	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-			"Broken panning specification '%s' for output %s in config file\n",

-			panning, output->name);

-	}

-    }

-}

-

-/** Return - 0 + if a should be earlier, same or later than b in list

- */

-static int

-xf86ModeCompare (DisplayModePtr a, DisplayModePtr b)

-{

-    int	diff;

-

-    diff = ((b->type & M_T_PREFERRED) != 0) - ((a->type & M_T_PREFERRED) != 0);

-    if (diff)

-	return diff;

-    diff = b->HDisplay * b->VDisplay - a->HDisplay * a->VDisplay;

-    if (diff)

-	return diff;

-    diff = b->Clock - a->Clock;

-    return diff;

-}

-

-/**

- * Insertion sort input in-place and return the resulting head

- */

-static DisplayModePtr

-xf86SortModes (DisplayModePtr input)

-{

-    DisplayModePtr  output = NULL, i, o, n, *op, prev;

-

-    /* sort by preferred status and pixel area */

-    while (input)

-    {

-	i = input;

-	input = input->next;

-	for (op = &output; (o = *op); op = &o->next)

-	    if (xf86ModeCompare (o, i) > 0)

-		break;

-	i->next = *op;

-	*op = i;

-    }

-    /* prune identical modes */

-    for (o = output; o && (n = o->next); o = n)

-    {

-	if (!strcmp (o->name, n->name) && xf86ModesEqual (o, n))

-	{

-	    o->next = n->next;

-	    free(n->name);

-	    free(n);

-	    n = o;

-	}

-    }

-    /* hook up backward links */

-    prev = NULL;

-    for (o = output; o; o = o->next)

-    {

-	o->prev = prev;

-	prev = o;

-    }

-    return output;

-}

-

-static char *

-preferredMode(ScrnInfoPtr pScrn, xf86OutputPtr output)

-{

-    char *preferred_mode = NULL;

-

-    /* Check for a configured preference for a particular mode */

-    preferred_mode = xf86GetOptValString (output->options,

-					  OPTION_PREFERRED_MODE);

-    if (preferred_mode)

-	return preferred_mode;

-

-    if (pScrn->display->modes && *pScrn->display->modes)

-	preferred_mode = *pScrn->display->modes;

-

-    return preferred_mode;

-}

-

-static void

-GuessRangeFromModes(MonPtr mon, DisplayModePtr mode)

-{

-    if (!mon || !mode)

-       return;

-

-    mon->nHsync = 1;

-    mon->hsync[0].lo = 1024.0;

-    mon->hsync[0].hi = 0.0;

-

-    mon->nVrefresh = 1;

-    mon->vrefresh[0].lo = 1024.0;

-    mon->vrefresh[0].hi = 0.0;

-

-    while (mode) {

-	if (!mode->HSync)

-	    mode->HSync = ((float) mode->Clock ) / ((float) mode->HTotal);

-

-	if (!mode->VRefresh)

-	    mode->VRefresh = (1000.0 * ((float) mode->Clock)) / 

-		((float) (mode->HTotal * mode->VTotal));

-

-	if (mode->HSync < mon->hsync[0].lo)

-	    mon->hsync[0].lo = mode->HSync;

-

-	if (mode->HSync > mon->hsync[0].hi)

-	    mon->hsync[0].hi = mode->HSync;

-

-	if (mode->VRefresh < mon->vrefresh[0].lo)

-	    mon->vrefresh[0].lo = mode->VRefresh;

-

-	if (mode->VRefresh > mon->vrefresh[0].hi)

-	    mon->vrefresh[0].hi = mode->VRefresh;

-

-	mode = mode->next;

-    }

-

-    /* stretch out the bottom to fit 640x480@60 */

-    if (mon->hsync[0].lo > 31.0)

-       mon->hsync[0].lo = 31.0;

-    if (mon->vrefresh[0].lo > 58.0)

-       mon->vrefresh[0].lo = 58.0;

-}

-

-enum det_monrec_source {

-    sync_config, sync_edid, sync_default

-};

-

-struct det_monrec_parameter {

-    MonRec *mon_rec;

-    int *max_clock;

-    Bool set_hsync;

-    Bool set_vrefresh;

-    enum det_monrec_source *sync_source;

-};

-

-static void handle_detailed_monrec(struct detailed_monitor_section *det_mon,

-                                   void *data)

-{

-    struct det_monrec_parameter *p;

-    p = (struct det_monrec_parameter *)data;

-

-    if (det_mon->type == DS_RANGES) {

-        struct monitor_ranges *ranges = &det_mon->section.ranges;

-        if (p->set_hsync && ranges->max_h) {

-            p->mon_rec->hsync[p->mon_rec->nHsync].lo = ranges->min_h;

-            p->mon_rec->hsync[p->mon_rec->nHsync].hi = ranges->max_h;

-            p->mon_rec->nHsync++;

-            if (*p->sync_source == sync_default)

-                *p->sync_source = sync_edid;

-        }

-        if (p->set_vrefresh && ranges->max_v) {

-            p->mon_rec->vrefresh[p->mon_rec->nVrefresh].lo = ranges->min_v;

-            p->mon_rec->vrefresh[p->mon_rec->nVrefresh].hi = ranges->max_v;

-            p->mon_rec->nVrefresh++;

-            if (*p->sync_source == sync_default)

-                *p->sync_source = sync_edid;

-        }

-        if (ranges->max_clock * 1000 > *p->max_clock)

-            *p->max_clock = ranges->max_clock * 1000;

-    }

-}

-

-void

-xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o;

-

-    /* When canGrow was TRUE in the initial configuration we have to

-     * compare against the maximum values so that we don't drop modes.

-     * When canGrow was FALSE, the maximum values would have been clamped

-     * anyway.

-     */

-    if (maxX == 0 || maxY == 0) {

-	maxX = config->maxWidth;

-	maxY = config->maxHeight;

-    }

-

-    /* Probe the list of modes for each output. */

-    for (o = 0; o < config->num_output; o++) 

-    {

-	xf86OutputPtr	    output = config->output[o];

-	DisplayModePtr	    mode;

-	DisplayModePtr	    config_modes = NULL, output_modes, default_modes = NULL;

-	char		    *preferred_mode;

-	xf86MonPtr	    edid_monitor;

-	XF86ConfMonitorPtr  conf_monitor;

-	MonRec		    mon_rec;

-	int		    min_clock = 0;

-	int		    max_clock = 0;

-	double		    clock;

-	Bool		    add_default_modes;

-	Bool		    debug_modes = config->debug_modes ||

-					  xf86Initialising;

-	enum det_monrec_source sync_source = sync_default;

-	

-	while (output->probed_modes != NULL)

-	    xf86DeleteMode(&output->probed_modes, output->probed_modes);

-

-	/*

-	 * Check connection status

-	 */

-	output->status = (*output->funcs->detect)(output);

-

-	if (output->status == XF86OutputStatusDisconnected &&

-		!xf86ReturnOptValBool(output->options, OPTION_ENABLE, FALSE))

-	{

-	    xf86OutputSetEDID (output, NULL);

-	    continue;

-	}

-

-	memset (&mon_rec, '\0', sizeof (mon_rec));

-	

-	conf_monitor = output->conf_monitor;

-	

-	if (conf_monitor)

-	{

-	    int	i;

-	    

-	    for (i = 0; i < conf_monitor->mon_n_hsync; i++)

-	    {

-		mon_rec.hsync[mon_rec.nHsync].lo = conf_monitor->mon_hsync[i].lo;

-		mon_rec.hsync[mon_rec.nHsync].hi = conf_monitor->mon_hsync[i].hi;

-		mon_rec.nHsync++;

-		sync_source = sync_config;

-	    }

-	    for (i = 0; i < conf_monitor->mon_n_vrefresh; i++)

-	    {

-		mon_rec.vrefresh[mon_rec.nVrefresh].lo = conf_monitor->mon_vrefresh[i].lo;

-		mon_rec.vrefresh[mon_rec.nVrefresh].hi = conf_monitor->mon_vrefresh[i].hi;

-		mon_rec.nVrefresh++;

-		sync_source = sync_config;

-	    }

-	    config_modes = xf86GetMonitorModes (scrn, conf_monitor);

-	}

-	

-	output_modes = (*output->funcs->get_modes) (output);

-

-	/*

-	 * If the user has a preference, respect it.

-	 * Otherwise, don't second-guess the driver.

-	 */

-	if (!xf86GetOptValBool(output->options, OPTION_DEFAULT_MODES,

-			       &add_default_modes))

-	    add_default_modes = (output_modes == NULL);

-	

-	edid_monitor = output->MonInfo;

-	

-        if (edid_monitor)

-        {

-            struct det_monrec_parameter p;

-            struct disp_features    *features = &edid_monitor->features;

-

-	    /* if display is not continuous-frequency, don't add default modes */

-	    if (!GTF_SUPPORTED(features->msc))

-		add_default_modes = FALSE;

-

-	    p.mon_rec = &mon_rec;

-	    p.max_clock = &max_clock;

-	    p.set_hsync = mon_rec.nHsync == 0;

-	    p.set_vrefresh = mon_rec.nVrefresh == 0;

-	    p.sync_source = &sync_source;

-

-	    xf86ForEachDetailedBlock(edid_monitor,

-			             handle_detailed_monrec,

-			             &p);

-	}

-

-	if (xf86GetOptValFreq (output->options, OPTION_MIN_CLOCK,

-			       OPTUNITS_KHZ, &clock))

-	    min_clock = (int) clock;

-	if (xf86GetOptValFreq (output->options, OPTION_MAX_CLOCK,

-			       OPTUNITS_KHZ, &clock))

-	    max_clock = (int) clock;

-

-	/* If we still don't have a sync range, guess wildly */

-	if (!mon_rec.nHsync || !mon_rec.nVrefresh)

-	    GuessRangeFromModes(&mon_rec, output_modes);

-

-	/*

-	 * These limits will end up setting a 1024x768@60Hz mode by default,

-	 * which seems like a fairly good mode to use when nothing else is

-	 * specified

-	 */

-	if (mon_rec.nHsync == 0)

-	{

-	    mon_rec.hsync[0].lo = 31.0;

-	    mon_rec.hsync[0].hi = 55.0;

-	    mon_rec.nHsync = 1;

-	}

-	if (mon_rec.nVrefresh == 0)

-	{

-	    mon_rec.vrefresh[0].lo = 58.0;

-	    mon_rec.vrefresh[0].hi = 62.0;

-	    mon_rec.nVrefresh = 1;

-	}

-

-	if (add_default_modes)

-	    default_modes = xf86GetDefaultModes ();

-

-	/*

-	 * If this is not an RB monitor, remove RB modes from the default

-	 * pool.  RB modes from the config or the monitor itself are fine.

-	 */

-	if (!mon_rec.reducedblanking)

-	    xf86ValidateModesReducedBlanking (scrn, default_modes);

-

-	if (sync_source == sync_config)

-	{

-	    /* 

-	     * Check output and config modes against sync range from config file

-	     */

-	    xf86ValidateModesSync (scrn, output_modes, &mon_rec);

-	    xf86ValidateModesSync (scrn, config_modes, &mon_rec);

-	}

-	/*

-	 * Check default modes against sync range

-	 */

-        xf86ValidateModesSync (scrn, default_modes, &mon_rec);

-	/*

-	 * Check default modes against monitor max clock

-	 */

-	if (max_clock) {

-	    xf86ValidateModesClocks(scrn, default_modes,

-				    &min_clock, &max_clock, 1);

-	    xf86ValidateModesClocks(scrn, output_modes,

-				    &min_clock, &max_clock, 1);

-	}

-	

-	output->probed_modes = NULL;

-	output->probed_modes = xf86ModesAdd (output->probed_modes, config_modes);

-	output->probed_modes = xf86ModesAdd (output->probed_modes, output_modes);

-	output->probed_modes = xf86ModesAdd (output->probed_modes, default_modes);

-	

-	/*

-	 * Check all modes against max size, interlace, and doublescan

-	 */

-	if (maxX && maxY)

-	    xf86ValidateModesSize (scrn, output->probed_modes,

-				       maxX, maxY, 0);

-

-	{

-	    int flags = (output->interlaceAllowed ? V_INTERLACE : 0) |

-			(output->doubleScanAllowed ? V_DBLSCAN : 0);

-	    xf86ValidateModesFlags (scrn, output->probed_modes, flags);

-	}

-	 

-	/*

-	 * Check all modes against output

-	 */

-	for (mode = output->probed_modes; mode != NULL; mode = mode->next) 

-	    if (mode->status == MODE_OK)

-		mode->status = (*output->funcs->mode_valid)(output, mode);

-	

-	xf86PruneInvalidModes(scrn, &output->probed_modes, debug_modes);

-	

-	output->probed_modes = xf86SortModes (output->probed_modes);

-	

-	/* Check for a configured preference for a particular mode */

-	preferred_mode = preferredMode(scrn, output);

-

-	if (preferred_mode)

-	{

-	    for (mode = output->probed_modes; mode; mode = mode->next)

-	    {

-		if (!strcmp (preferred_mode, mode->name))

-		{

-		    if (mode != output->probed_modes)

-		    {

-			if (mode->prev)

-			    mode->prev->next = mode->next;

-			if (mode->next)

-			    mode->next->prev = mode->prev;

-			mode->next = output->probed_modes;

-			output->probed_modes->prev = mode;

-			mode->prev = NULL;

-			output->probed_modes = mode;

-		    }

-		    mode->type |= (M_T_PREFERRED|M_T_USERPREF);

-		    break;

-		}

-	    }

-	}

-	

-	output->initial_rotation = xf86OutputInitialRotation (output);

-

-	if (debug_modes) {

-	    if (output->probed_modes != NULL) {

-		xf86DrvMsg(scrn->scrnIndex, X_INFO,

-			   "Printing probed modes for output %s\n",

-			   output->name);

-	    } else {

-		xf86DrvMsg(scrn->scrnIndex, X_INFO,

-			   "No remaining probed modes for output %s\n",

-			   output->name);

-	    }

-	}

-	for (mode = output->probed_modes; mode != NULL; mode = mode->next)

-	{

-	    /* The code to choose the best mode per pipe later on will require

-	     * VRefresh to be set.

-	     */

-	    mode->VRefresh = xf86ModeVRefresh(mode);

-	    xf86SetModeCrtc(mode, INTERLACE_HALVE_V);

-

-	    if (debug_modes)

-		xf86PrintModeline(scrn->scrnIndex, mode);

-	}

-    }

-}

-

-

-/**

- * Copy one of the output mode lists to the ScrnInfo record

- */

-

-/* XXX where does this function belong? Here? */

-void

-xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr scrn, int *x, int *y);

-

-static DisplayModePtr

-biggestMode(DisplayModePtr a, DisplayModePtr b)

-{

-    int A, B;

-

-    if (!a)

-	return b;

-    if (!b)

-	return a;

-

-    A = a->HDisplay * a->VDisplay;

-    B = b->HDisplay * b->VDisplay;

-

-    if (A > B)

-	return a;

-

-    return b;

-}

-

-static xf86OutputPtr

-SetCompatOutput(xf86CrtcConfigPtr config)

-{

-    xf86OutputPtr output = NULL, test = NULL;

-    DisplayModePtr maxmode = NULL, testmode, mode;

-    int o, compat = -1, count, mincount = 0;

-

-    /* Look for one that's definitely connected */

-    for (o = 0; o < config->num_output; o++)

-    {

-	test = config->output[o];

-	if (!test->crtc)

-	    continue;

-	if (test->status != XF86OutputStatusConnected)

-	    continue;

-	if (!test->probed_modes)

-	    continue;

-

-	testmode = mode = test->probed_modes;

-	for (count = 0; mode; mode = mode->next, count++)

-	    testmode = biggestMode(testmode, mode);

-

-	if (!output) {

-	    output = test;

-	    compat = o;

-	    maxmode = testmode;

-	    mincount = count;

-	} else if (maxmode == biggestMode(maxmode, testmode)) {

-	    output = test;

-	    compat = o;

-	    maxmode = testmode;

-	    mincount = count;

-	} else if ((maxmode->HDisplay == testmode->HDisplay) && 

-		(maxmode->VDisplay == testmode->VDisplay) &&

-		count <= mincount) {

-	    output = test;

-	    compat = o;

-	    maxmode = testmode;

-	    mincount = count;

-	}

-    }

-

-    /* If we didn't find one, take anything we can get */

-    if (!output)

-    {

-	for (o = 0; o < config->num_output; o++)

-	{

-	    test = config->output[o];

-	    if (!test->crtc)

-		continue;

-	    if (!test->probed_modes)

-		continue;

-

-	    if (!output) {

-		output = test;

-		compat = o;

-	    } else if (test->probed_modes->HDisplay < output->probed_modes->HDisplay) {

-		output = test;

-		compat = o;

-	    }

-	}

-    }

-

-    if (compat >= 0) {

-	config->compat_output = compat;

-    } else {

-	/* Don't change the compat output when no valid outputs found */

-	output = config->output[config->compat_output];

-    }

-

-    return output;

-}

-

-void

-xf86SetScrnInfoModes (ScrnInfoPtr scrn)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    xf86OutputPtr	output;

-    xf86CrtcPtr		crtc;

-    DisplayModePtr	last, mode = NULL;

-

-    output = SetCompatOutput(config);

-

-    if (!output)

-	return; /* punt */

-

-    crtc = output->crtc;

-

-    /* Clear any existing modes from scrn->modes */

-    while (scrn->modes != NULL)

-	xf86DeleteMode(&scrn->modes, scrn->modes);

-

-    /* Set scrn->modes to the mode list for the 'compat' output */

-    scrn->modes = xf86DuplicateModes(scrn, output->probed_modes);

-

-    if (crtc) {

-	for (mode = scrn->modes; mode; mode = mode->next)

-	    if (xf86ModesEqual (mode, &crtc->desiredMode))

-		break;

-    }

-

-    if (scrn->modes != NULL) {

-	/* For some reason, scrn->modes is circular, unlike the other mode

-	 * lists.  How great is that?

-	 */

-	for (last = scrn->modes; last && last->next; last = last->next)

-	    ;

-	last->next = scrn->modes;

-	scrn->modes->prev = last;

-	if (mode) {

-	    while (scrn->modes != mode)

-		scrn->modes = scrn->modes->next;

-	}

-    }

-    scrn->currentMode = scrn->modes;

-#ifdef XFreeXDGA

-    if (scrn->pScreen)

-	    _xf86_di_dga_reinit_internal(scrn->pScreen);

-#endif

-}

-

-static Bool

-xf86CollectEnabledOutputs(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,

-			  Bool *enabled)

-{

-    Bool any_enabled = FALSE;

-    int o;

-

-    for (o = 0; o < config->num_output; o++)

-	any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], TRUE);

-    

-    if (!any_enabled) {

-	xf86DrvMsg(scrn->scrnIndex, X_WARNING,

-		   "No outputs definitely connected, trying again...\n");

-

-	for (o = 0; o < config->num_output; o++)

-	    any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], FALSE);

-    }

-

-    return any_enabled;

-}

-

-static Bool

-nextEnabledOutput(xf86CrtcConfigPtr config, Bool *enabled, int *index)

-{

-    int o = *index;

-

-    for (o++; o < config->num_output; o++) {

-	if (enabled[o]) {

-	    *index = o;

-	    return TRUE;

-	}

-    }

-    

-    return FALSE;

-}

-

-static Bool

-aspectMatch(float a, float b)

-{

-    return fabs(1 - (a / b)) < 0.05;

-}

-

-static DisplayModePtr

-nextAspectMode(xf86OutputPtr o, DisplayModePtr last, float aspect)

-{

-    DisplayModePtr m = NULL;

-

-    if (!o)

-	return NULL;

-

-    if (!last)

-	m = o->probed_modes;

-    else

-	m = last->next;

-

-    for (; m; m = m->next)

-	if (aspectMatch(aspect, (float)m->HDisplay / (float)m->VDisplay))

-	    return m;

-

-    return NULL;

-}

-

-static DisplayModePtr

-bestModeForAspect(xf86CrtcConfigPtr config, Bool *enabled, float aspect)

-{

-    int o = -1, p;

-    DisplayModePtr mode = NULL, test = NULL, match = NULL;

-

-    if (!nextEnabledOutput(config, enabled, &o))

-	return NULL;

-    while ((mode = nextAspectMode(config->output[o], mode, aspect))) {

-	test = mode;

-	for (p = o; nextEnabledOutput(config, enabled, &p); ) {

-	    test = xf86OutputFindClosestMode(config->output[p], mode);

-	    if (!test)

-		break;

-	    if (test->HDisplay != mode->HDisplay ||

-		    test->VDisplay != mode->VDisplay) {

-		test = NULL;

-		break;

-	    }

-	}

-

-	/* if we didn't match it on all outputs, try the next one */

-	if (!test)

-	    continue;

-

-	/* if it's bigger than the last one, save it */

-	if (!match || (test->HDisplay > match->HDisplay))

-	    match = test;

-    }

-

-    /* return the biggest one found */

-    return match;

-}

-

-static Bool

-xf86TargetPreferred(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,

-		    DisplayModePtr *modes, Bool *enabled,

-		    int width, int height)

-{

-    int o, p;

-    int max_pref_width = 0, max_pref_height = 0;

-    DisplayModePtr *preferred, *preferred_match;

-    Bool ret = FALSE;

-

-    preferred = xnfcalloc(config->num_output, sizeof(DisplayModePtr));

-    preferred_match = xnfcalloc(config->num_output, sizeof(DisplayModePtr));

-

-    /* Check if the preferred mode is available on all outputs */

-    for (p = -1; nextEnabledOutput(config, enabled, &p); ) {

-	Rotation r = config->output[p]->initial_rotation;

-	DisplayModePtr mode;

-	if ((preferred[p] = xf86OutputHasPreferredMode(config->output[p],

-			width, height))) {

-	    int pref_width = xf86ModeWidth(preferred[p], r);

-	    int pref_height = xf86ModeHeight(preferred[p], r);

-	    Bool all_match = TRUE;

-

-	    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-		Bool match = FALSE;

-		xf86OutputPtr output = config->output[o];

-		if (o == p)

-		    continue;

-

-		for (mode = output->probed_modes; mode; mode = mode->next) {

-		    Rotation r = output->initial_rotation;

-		    if (xf86ModeWidth(mode, r) == pref_width &&

-			    xf86ModeHeight(mode, r) == pref_height) {

-			preferred[o] = mode;

-			match = TRUE;

-		    }

-		}

-

-		all_match &= match;

-	    }

-

-	    if (all_match &&

-		    (pref_width*pref_height > max_pref_width*max_pref_height)) {

-		for (o = -1; nextEnabledOutput(config, enabled, &o); )

-		    preferred_match[o] = preferred[o];

-		max_pref_width = pref_width;

-		max_pref_height = pref_height;

-		ret = TRUE;

-	    }

-	}

-    }

-

-    /*

-     * If there's no preferred mode, but only one monitor, pick the

-     * biggest mode for its aspect ratio, assuming one exists.

-     */

-    if (!ret) do {

-	int i = 0;

-	float aspect = 0.0;

-

-	/* count the number of enabled outputs */

-	for (i = 0, p = -1; nextEnabledOutput(config, enabled, &p); i++) ;

-

-	if (i != 1)

-	    break;

-

-	p = -1;

-	nextEnabledOutput(config, enabled, &p);

-	if (config->output[p]->mm_height)

-	    aspect = (float)config->output[p]->mm_width /

-		     (float)config->output[p]->mm_height;

-

-	if (aspect)

-	    preferred_match[p] = bestModeForAspect(config, enabled, aspect);

-

-	if (preferred_match[p])

-	    ret = TRUE;

-

-    } while (0);

-

-    if (ret) {

-	/* oh good, there is a match.  stash the selected modes and return. */

-	memcpy(modes, preferred_match,

-		config->num_output * sizeof(DisplayModePtr));

-    }

-

-    free(preferred);

-    free(preferred_match);

-    return ret;

-}

-

-static Bool

-xf86TargetAspect(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,

-		 DisplayModePtr *modes, Bool *enabled,

-		 int width, int height)

-{

-    int o;

-    float aspect = 0.0, *aspects;

-    xf86OutputPtr output;

-    Bool ret = FALSE;

-    DisplayModePtr guess = NULL, aspect_guess = NULL, base_guess = NULL;

-

-    aspects = xnfcalloc(config->num_output, sizeof(float));

-

-    /* collect the aspect ratios */

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	output = config->output[o];

-	if (output->mm_height)

-	    aspects[o] = (float)output->mm_width / (float)output->mm_height;

-	else

-	    aspects[o] = 4.0 / 3.0;

-    }

-

-    /* check that they're all the same */

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	output = config->output[o];

-	if (!aspect) {

-	    aspect = aspects[o];

-	} else if (!aspectMatch(aspect, aspects[o])) {

-	    goto no_aspect_match;

-	}

-    }

-

-    /* if they're all 4:3, just skip ahead and save effort */

-    if (!aspectMatch(aspect, 4.0/3.0))

-	aspect_guess = bestModeForAspect(config, enabled, aspect);

-

-no_aspect_match:

-    base_guess = bestModeForAspect(config, enabled, 4.0/3.0);

-

-    guess = biggestMode(base_guess, aspect_guess);

-

-    if (!guess)

-	goto out;

-

-    /* found a mode that works everywhere, now apply it */

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	modes[o] = xf86OutputFindClosestMode(config->output[o], guess);

-    }

-    ret = TRUE;

-

-out:

-    free(aspects);

-    return ret;

-}

-

-static Bool

-xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,

-		   DisplayModePtr *modes, Bool *enabled,

-		   int width, int height)

-{

-    DisplayModePtr target_mode = NULL;

-    Rotation target_rotation = RR_Rotate_0;

-    DisplayModePtr default_mode;

-    int default_preferred, target_preferred = 0, o;

-

-    /* User preferred > preferred > other modes */

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	default_mode = xf86DefaultMode (config->output[o], width, height);

-	if (!default_mode)

-	    continue;

-

-	default_preferred = (((default_mode->type & M_T_PREFERRED) != 0) +

-		((default_mode->type & M_T_USERPREF) != 0));

-

-	if (default_preferred > target_preferred || !target_mode) {

-	    target_mode = default_mode;

-	    target_preferred = default_preferred;

-	    target_rotation = config->output[o]->initial_rotation;

-	    config->compat_output = o;

-	}

-    }

-

-    if (target_mode)

-	modes[config->compat_output] = target_mode;

-

-    /* Fill in other output modes */

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	if (!modes[o])

-	    modes[o] = xf86ClosestMode(config->output[o], target_mode,

-				       target_rotation, width, height);

-    }

-

-    return target_mode != NULL;

-}

-

-static Bool

-xf86TargetUserpref(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,

-		   DisplayModePtr *modes, Bool *enabled,

-		   int width, int height)

-{

-    int o;

-

-    if (xf86UserConfiguredOutputs(scrn, modes))

-	return xf86TargetFallback(scrn, config, modes, enabled, width, height);

-    

-    for (o = -1; nextEnabledOutput(config, enabled, &o); )

-	if (xf86OutputHasUserPreferredMode(config->output[o]))

-	    return 

-		xf86TargetFallback(scrn, config, modes, enabled, width, height);

-

-    return FALSE;

-}

-

-static Bool

-xf86CrtcSetInitialGamma(xf86CrtcPtr crtc, float gamma_red, float gamma_green,

-        float gamma_blue)

-{

-    int i, size = 256;

-    CARD16 *red, *green, *blue;

-

-    red = malloc(3 * size * sizeof(CARD16));

-    green = red + size;

-    blue = green + size;

-

-     /* Only cause warning if user wanted gamma to be set. */

-    if (!crtc->funcs->gamma_set && (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0)) {

-        free(red);

-        return FALSE;

-    } else if (!crtc->funcs->gamma_set) {

-        free(red);

-        return TRUE;

-      }

-

-    /* At this early stage none of the randr-interface stuff is up.

-     * So take the default gamma size for lack of something better.

-     */

-    for (i = 0; i < size; i++) {

-        if (gamma_red == 1.0)

-            red[i] = i << 8;

-        else

-            red[i] = (CARD16)(pow((double)i/(double)(size - 1),

-			1. / (double)gamma_red) * (double)(size - 1) * 256);

-

-        if (gamma_green == 1.0)

-            green[i] = i << 8;

-        else

-            green[i] = (CARD16)(pow((double)i/(double)(size - 1),

-			1. / (double)gamma_green) * (double)(size - 1) * 256);

-

-        if (gamma_blue == 1.0)

-            blue[i] = i << 8;

-        else

-            blue[i] = (CARD16)(pow((double)i/(double)(size - 1),

-			1. / (double)gamma_blue) * (double)(size - 1) * 256);

-    }

-

-    /* Default size is 256, so anything else is failure. */

-    if (size != crtc->gamma_size) {

-        free(red);

-        return FALSE;

-      }

-

-    crtc->gamma_size = size;

-    memcpy (crtc->gamma_red, red, crtc->gamma_size * sizeof (CARD16));

-    memcpy (crtc->gamma_green, green, crtc->gamma_size * sizeof (CARD16));

-    memcpy (crtc->gamma_blue, blue, crtc->gamma_size * sizeof (CARD16));

-

-    /* Do not set gamma now, delay until the crtc is activated. */

-

-    free(red);

-

-    return TRUE;

-}

-

-static Bool

-xf86OutputSetInitialGamma(xf86OutputPtr output)

-{

-    XF86ConfMonitorPtr mon = output->conf_monitor;

-    float gamma_red = 1.0, gamma_green = 1.0, gamma_blue = 1.0;

-    

-    if (!mon)

-        return TRUE;

-

-    if (!output->crtc)

-        return FALSE;

-

-    /* Get configured values, where they exist. */

-    if (mon->mon_gamma_red >= GAMMA_MIN &&

-        mon->mon_gamma_red <= GAMMA_MAX)

-            gamma_red = mon->mon_gamma_red;

-

-    if (mon->mon_gamma_green >= GAMMA_MIN &&

-        mon->mon_gamma_green <= GAMMA_MAX)

-            gamma_green = mon->mon_gamma_green;

-

-    if (mon->mon_gamma_blue >= GAMMA_MIN &&

-        mon->mon_gamma_blue <= GAMMA_MAX)

-            gamma_blue = mon->mon_gamma_blue;

-

-    /* This avoids setting gamma 1.0 in case another cloned output on this crtc has a specific gamma. */

-    if (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0) {

-	xf86DrvMsg(output->scrn->scrnIndex, X_INFO, "Output %s wants gamma correction (%.1f, %.1f, %.1f)\n", output->name, gamma_red, gamma_green, gamma_blue);

-	return xf86CrtcSetInitialGamma(output->crtc, gamma_red, gamma_green, gamma_blue);

-    }else

-	return TRUE;

-}

-

-/**

- * Construct default screen configuration

- *

- * Given auto-detected (and, eventually, configured) values,

- * construct a usable configuration for the system

- *

- * canGrow indicates that the driver can resize the screen to larger than its

- * initially configured size via the config->funcs->resize hook.  If TRUE, this

- * function will set virtualX and virtualY to match the initial configuration

- * and leave config->max{Width,Height} alone.  If FALSE, it will bloat

- * virtual[XY] to include the largest modes and set config->max{Width,Height}

- * accordingly.

- */

-

-Bool

-xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o, c;

-    xf86CrtcPtr		*crtcs;

-    DisplayModePtr	*modes;

-    Bool		*enabled;

-    int			width, height;

-    int			i = scrn->scrnIndex;

-    Bool have_outputs = TRUE;

-    Bool ret;

-    Bool success = FALSE;

-

-    /* Set up the device options */

-    config->options = xnfalloc (sizeof (xf86DeviceOptions));

-    memcpy (config->options, xf86DeviceOptions, sizeof (xf86DeviceOptions));

-    xf86ProcessOptions (scrn->scrnIndex,

-			scrn->options,

-			config->options);

-    config->debug_modes = xf86ReturnOptValBool (config->options,

-						OPTION_MODEDEBUG, FALSE);

-

-    if (scrn->display->virtualX)

-	width = scrn->display->virtualX;

-    else

-	width = config->maxWidth;

-    if (scrn->display->virtualY)

-	height = scrn->display->virtualY;

-    else

-	height = config->maxHeight;

-

-    xf86ProbeOutputModes (scrn, width, height);

-

-    crtcs = xnfcalloc (config->num_output, sizeof (xf86CrtcPtr));

-    modes = xnfcalloc (config->num_output, sizeof (DisplayModePtr));

-    enabled = xnfcalloc (config->num_output, sizeof (Bool));

-    

-    ret = xf86CollectEnabledOutputs(scrn, config, enabled);

-    if (ret == FALSE && canGrow) {

-	xf86DrvMsg(i, X_WARNING, "Unable to find connected outputs - setting %dx%d initial framebuffer\n",

-		   NO_OUTPUT_DEFAULT_WIDTH, NO_OUTPUT_DEFAULT_HEIGHT);

-	have_outputs = FALSE;

-    } else {

-	if (xf86TargetUserpref(scrn, config, modes, enabled, width, height))

-	    xf86DrvMsg(i, X_INFO, "Using user preference for initial modes\n");

-	else if (xf86TargetPreferred(scrn, config, modes, enabled, width, height))

-	    xf86DrvMsg(i, X_INFO, "Using exact sizes for initial modes\n");

-	else if (xf86TargetAspect(scrn, config, modes, enabled, width, height))

-	    xf86DrvMsg(i, X_INFO, "Using fuzzy aspect match for initial modes\n");

-	else if (xf86TargetFallback(scrn, config, modes, enabled, width, height))

-	    xf86DrvMsg(i, X_INFO, "Using sloppy heuristic for initial modes\n");

-	else

-	    xf86DrvMsg(i, X_WARNING, "Unable to find initial modes\n");

-    }

-

-    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {

-	if (!modes[o])

-	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,

-			"Output %s enabled but has no modes\n",

-			config->output[o]->name);

-	else

-	    xf86DrvMsg (scrn->scrnIndex, X_INFO,

-			"Output %s using initial mode %s\n",

-			config->output[o]->name, modes[o]->name);

-    }

-

-    /*

-     * Set the position of each output

-     */

-    if (!xf86InitialOutputPositions (scrn, modes))

-	goto bailout;

-

-    /*

-     * Set initial panning of each output

-     */

-    xf86InitialPanning (scrn);

-	

-    /*

-     * Assign CRTCs to fit output configuration

-     */

-    if (have_outputs && !xf86PickCrtcs (scrn, crtcs, modes, 0, width, height))

-	goto bailout;

-    

-    /* XXX override xf86 common frame computation code */

-    

-    scrn->display->frameX0 = 0;

-    scrn->display->frameY0 = 0;

-    

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	xf86CrtcPtr	crtc = config->crtc[c];

-

-	crtc->enabled = FALSE;

-	memset (&crtc->desiredMode, '\0', sizeof (crtc->desiredMode));

-	/* Set default gamma for all crtc's. */

-	/* This is done to avoid problems later on with cloned outputs. */

-	xf86CrtcSetInitialGamma(crtc, 1.0, 1.0, 1.0);

-    }

-

-    if (xf86_crtc_supports_gamma(scrn))

-	xf86DrvMsg(scrn->scrnIndex, X_INFO, "Using default gamma of (1.0, 1.0, 1.0) unless otherwise stated.\n");

-

-    /*

-     * Set initial configuration

-     */

-    for (o = 0; o < config->num_output; o++)

-    {

-	xf86OutputPtr	output = config->output[o];

-	DisplayModePtr	mode = modes[o];

-        xf86CrtcPtr	crtc = crtcs[o];

-

-	if (mode && crtc)

-	{

-	    crtc->desiredMode = *mode;

-	    crtc->desiredRotation = output->initial_rotation;

-	    crtc->desiredX = output->initial_x;

-	    crtc->desiredY = output->initial_y;

-	    crtc->desiredTransformPresent = FALSE;

-	    crtc->enabled = TRUE;

-	    memcpy (&crtc->panningTotalArea,    &output->initialTotalArea,    sizeof(BoxRec));

-	    memcpy (&crtc->panningTrackingArea, &output->initialTrackingArea, sizeof(BoxRec));

-	    memcpy (crtc->panningBorder,        output->initialBorder,        4*sizeof(INT16));

-	    output->crtc = crtc;

-	    if (!xf86OutputSetInitialGamma(output))

-		xf86DrvMsg (scrn->scrnIndex, X_WARNING, "Initial gamma correction for output %s: failed.\n", output->name);

-	} else {

-	    output->crtc = NULL;

-	}

-    }

-

-    if (scrn->display->virtualX == 0)

-    {

-	/*

-	 * Expand virtual size to cover the current config and potential mode

-	 * switches, if the driver can't enlarge the screen later.

-	 */

-	xf86DefaultScreenLimits (scrn, &width, &height, canGrow);

-    

-	if (have_outputs == FALSE) {

-	    if (width < NO_OUTPUT_DEFAULT_WIDTH && height < NO_OUTPUT_DEFAULT_HEIGHT) {

-		width = NO_OUTPUT_DEFAULT_WIDTH;

-		height = NO_OUTPUT_DEFAULT_HEIGHT;

-	    }

-	}

-

-	scrn->display->virtualX = width;

-	scrn->display->virtualY = height;

-    }

-

-    if (width > scrn->virtualX)

-	scrn->virtualX = width;

-    if (height > scrn->virtualY)

-	scrn->virtualY = height;

-

-    /*

-     * Make sure the configuration isn't too small.

-     */

-    if (width < config->minWidth || height < config->minHeight)

-	goto bailout;

-

-    /*

-     * Limit the crtc config to virtual[XY] if the driver can't grow the

-     * desktop.

-     */

-    if (!canGrow)

-    {

-	xf86CrtcSetSizeRange (scrn, config->minWidth, config->minHeight,

-			      width, height);

-    }

-

-    if (have_outputs) {

-	/* Mirror output modes to scrn mode list */

-	xf86SetScrnInfoModes (scrn);

-    } else {

-	/* Clear any existing modes from scrn->modes */

-	while (scrn->modes != NULL)

-	    xf86DeleteMode(&scrn->modes, scrn->modes);

-	scrn->modes = xf86ModesAdd(scrn->modes,

-				   xf86CVTMode(width, height, 60, 0, 0));

-    }

-

-    success = TRUE;

- bailout:

-    free(crtcs);

-    free(modes);

-    free(enabled);

-    return success;

-}

-

-/*

- * Check the CRTC we're going to map each output to vs. it's current

- * CRTC.  If they don't match, we have to disable the output and the CRTC

- * since the driver will have to re-route things.

- */

-static void

-xf86PrepareOutputs (ScrnInfoPtr scrn)

-{

-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			o;

-

-    for (o = 0; o < config->num_output; o++) {

-	xf86OutputPtr output = config->output[o];

-#if RANDR_GET_CRTC_INTERFACE

-	/* Disable outputs that are unused or will be re-routed */

-	if (!output->funcs->get_crtc ||

-	    output->crtc != (*output->funcs->get_crtc)(output) ||

-	    output->crtc == NULL)

-#endif

-	    (*output->funcs->dpms)(output, DPMSModeOff);

-    }

-}

-

-static void

-xf86PrepareCrtcs (ScrnInfoPtr scrn)

-{

-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			c;

-

-    for (c = 0; c < config->num_crtc; c++) {

-#if RANDR_GET_CRTC_INTERFACE

-	xf86CrtcPtr	crtc = config->crtc[c];

-	xf86OutputPtr	output = NULL;

-	uint32_t	desired_outputs = 0, current_outputs = 0;

-	int		o;

-

-	for (o = 0; o < config->num_output; o++) {

-	    output = config->output[o];

-	    if (output->crtc == crtc)

-		desired_outputs |= (1<<o);

-	    /* If we can't tell where it's mapped, force it off */

-	    if (!output->funcs->get_crtc) {

-		desired_outputs = 0;

-		break;

-	    }

-	    if ((*output->funcs->get_crtc)(output) == crtc)

-		current_outputs |= (1<<o);

-	}

-

-	/*

-	 * If mappings are different or the CRTC is unused,

-	 * we need to disable it

-	 */

-	if (desired_outputs != current_outputs ||

-	    !desired_outputs)

-	    (*crtc->funcs->dpms)(crtc, DPMSModeOff);

-#else

-	(*crtc->funcs->dpms)(crtc, DPMSModeOff);

-#endif

-    }

-}

-

-/*

- * Using the desired mode information in each crtc, set

- * modes (used in EnterVT functions, or at server startup)

- */

-

-Bool

-xf86SetDesiredModes (ScrnInfoPtr scrn)

-{

-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);

-    xf86CrtcPtr         crtc = config->crtc[0];

-    int			c;

-

-    /* A driver with this hook will take care of this */

-    if (!crtc->funcs->set_mode_major) {

-	xf86PrepareOutputs(scrn);

-	xf86PrepareCrtcs(scrn);

-    }

-

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	xf86OutputPtr	output = NULL;

-	int		o;

-	RRTransformPtr	transform;

-

-	crtc = config->crtc[c];

-

-	/* Skip disabled CRTCs */

-	if (!crtc->enabled)

-	    continue;

-

-	if (xf86CompatOutput(scrn) && xf86CompatCrtc(scrn) == crtc)

-	    output = xf86CompatOutput(scrn);

-	else

-	{

-	    for (o = 0; o < config->num_output; o++)

-		if (config->output[o]->crtc == crtc)

-		{

-		    output = config->output[o];

-		    break;

-		}

-	}

-	/* paranoia */

-	if (!output)

-	    continue;

-

-	/* Mark that we'll need to re-set the mode for sure */

-	memset(&crtc->mode, 0, sizeof(crtc->mode));

-	if (!crtc->desiredMode.CrtcHDisplay)

-	{

-	    DisplayModePtr  mode = xf86OutputFindClosestMode (output, scrn->currentMode);

-

-	    if (!mode)

-		return FALSE;

-	    crtc->desiredMode = *mode;

-	    crtc->desiredRotation = RR_Rotate_0;

-	    crtc->desiredTransformPresent = FALSE;

-	    crtc->desiredX = 0;

-	    crtc->desiredY = 0;

-	}

-

-	if (crtc->desiredTransformPresent)

-	    transform = &crtc->desiredTransform;

-	else

-	    transform = NULL;

-	if (!xf86CrtcSetModeTransform (crtc, &crtc->desiredMode, crtc->desiredRotation,

-				       transform, crtc->desiredX, crtc->desiredY))

-	    return FALSE;

-    }

-

-    xf86DisableUnusedFunctions(scrn);

-    return TRUE;

-}

-

-/**

- * In the current world order, there are lists of modes per output, which may

- * or may not include the mode that was asked to be set by XFree86's mode

- * selection.  Find the closest one, in the following preference order:

- *

- * - Equality

- * - Closer in size to the requested mode, but no larger

- * - Closer in refresh rate to the requested mode.

- */

-

-DisplayModePtr

-xf86OutputFindClosestMode (xf86OutputPtr output, DisplayModePtr desired)

-{

-    DisplayModePtr	best = NULL, scan = NULL;

-

-    for (scan = output->probed_modes; scan != NULL; scan = scan->next) 

-    {

-	/* If there's an exact match, we're done. */

-	if (xf86ModesEqual(scan, desired)) {

-	    best = desired;

-	    break;

-	}

-

-	/* Reject if it's larger than the desired mode. */

-	if (scan->HDisplay > desired->HDisplay || 

-	    scan->VDisplay > desired->VDisplay)

-	{

-	    continue;

-	}

-

-	/*

-	 * If we haven't picked a best mode yet, use the first

-	 * one in the size range

-	 */

-	if (best == NULL) 

-	{

-	    best = scan;

-	    continue;

-	}

-

-	/* Find if it's closer to the right size than the current best

-	 * option.

-	 */

-	if ((scan->HDisplay > best->HDisplay &&

-	     scan->VDisplay >= best->VDisplay) ||

-	    (scan->HDisplay >= best->HDisplay &&

-	     scan->VDisplay > best->VDisplay))

-	{

-	    best = scan;

-	    continue;

-	}

-

-	/* Find if it's still closer to the right refresh than the current

-	 * best resolution.

-	 */

-	if (scan->HDisplay == best->HDisplay &&

-	    scan->VDisplay == best->VDisplay &&

-	    (fabs(scan->VRefresh - desired->VRefresh) <

-	     fabs(best->VRefresh - desired->VRefresh))) {

-	    best = scan;

-	}

-    }

-    return best;

-}

-

-/**

- * When setting a mode through XFree86-VidModeExtension or XFree86-DGA,

- * take the specified mode and apply it to the crtc connected to the compat

- * output. Then, find similar modes for the other outputs, as with the

- * InitialConfiguration code above. The goal is to clone the desired

- * mode across all outputs that are currently active.

- */

-

-Bool

-xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);

-    Bool		ok = TRUE;

-    xf86OutputPtr	compat_output;

-    DisplayModePtr	compat_mode = NULL;

-    int			c;

-

-    /*

-     * Let the compat output drive the final mode selection

-     */

-    compat_output = xf86CompatOutput(pScrn);

-    if (compat_output)

-	compat_mode = xf86OutputFindClosestMode (compat_output, desired);

-    if (compat_mode)

-	desired = compat_mode;

-    

-    for (c = 0; c < config->num_crtc; c++)

-    {

-	xf86CrtcPtr	crtc = config->crtc[c];

-	DisplayModePtr	crtc_mode = NULL;

-	int		o;

-

-	if (!crtc->enabled)

-	    continue;

-	

-	for (o = 0; o < config->num_output; o++)

-	{

-	    xf86OutputPtr   output = config->output[o];

-	    DisplayModePtr  output_mode;

-

-	    /* skip outputs not on this crtc */

-	    if (output->crtc != crtc)

-		continue;

-	    

-	    if (crtc_mode)

-	    {

-		output_mode = xf86OutputFindClosestMode (output, crtc_mode);

-		if (output_mode != crtc_mode)

-		    output->crtc = NULL;

-	    }

-	    else

-		crtc_mode = xf86OutputFindClosestMode (output, desired);

-	}

-	if (!crtc_mode)

-	{

-	    crtc->enabled = FALSE;

-	    continue;

-	}

-	if (!xf86CrtcSetModeTransform (crtc, crtc_mode, rotation, NULL, 0, 0))

-	    ok = FALSE;

-	else

-	{

-	    crtc->desiredMode = *crtc_mode;

-	    crtc->desiredRotation = rotation;

-	    crtc->desiredTransformPresent = FALSE;

-	    crtc->desiredX = 0;

-	    crtc->desiredY = 0;

-	}

-    }

-    xf86DisableUnusedFunctions(pScrn);

-#ifdef RANDR_12_INTERFACE

-    xf86RandR12TellChanged (pScrn->pScreen);

-#endif

-    return ok;

-}

-

-

-/**

- * Set the DPMS power mode of all outputs and CRTCs.

- *

- * If the new mode is off, it will turn off outputs and then CRTCs.

- * Otherwise, it will affect CRTCs before outputs.

- */

-void

-xf86DPMSSet(ScrnInfoPtr scrn, int mode, int flags)

-{

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    int			i;

-

-    if (!scrn->vtSema)

-	return;

-

-    if (mode == DPMSModeOff) {

-	for (i = 0; i < config->num_output; i++) {

-	    xf86OutputPtr output = config->output[i];

-	    if (output->crtc != NULL)

-		(*output->funcs->dpms) (output, mode);

-	}

-    }

-

-    for (i = 0; i < config->num_crtc; i++) {

-	xf86CrtcPtr crtc = config->crtc[i];

-	if (crtc->enabled)

-	    (*crtc->funcs->dpms) (crtc, mode);

-    }

-

-    if (mode != DPMSModeOff) {

-	for (i = 0; i < config->num_output; i++) {

-	    xf86OutputPtr output = config->output[i];

-	    if (output->crtc != NULL)

-		(*output->funcs->dpms) (output, mode);

-	}

-    }

-}

-

-/**

- * Implement the screensaver by just calling down into the driver DPMS hooks.

- *

- * Even for monitors with no DPMS support, by the definition of our DPMS hooks,

- * the outputs will still get disabled (blanked).

- */

-Bool

-xf86SaveScreen(ScreenPtr pScreen, int mode)

-{

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

-

-    if (xf86IsUnblank(mode))

-	xf86DPMSSet(pScrn, DPMSModeOn, 0);

-    else

-	xf86DPMSSet(pScrn, DPMSModeOff, 0);

-

-    return TRUE;

-}

-

-/**

- * Disable all inactive crtcs and outputs

- */

-void

-xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)

-{

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);

-    int			o, c;

-

-    for (o = 0; o < xf86_config->num_output; o++) 

-    {

-	xf86OutputPtr  output = xf86_config->output[o];

-	if (!output->crtc) 

-	    (*output->funcs->dpms)(output, DPMSModeOff);

-    }

-

-    for (c = 0; c < xf86_config->num_crtc; c++) 

-    {

-	xf86CrtcPtr crtc = xf86_config->crtc[c];

-

-	if (!crtc->enabled) 

-	{

-	    crtc->funcs->dpms(crtc, DPMSModeOff);

-	    memset(&crtc->mode, 0, sizeof(crtc->mode));

-	    xf86RotateDestroy(crtc);

-	    crtc->active = FALSE;

-	}

-    }

-    if (pScrn->pScreen)

-	xf86_crtc_notify(pScrn->pScreen);

-    if (pScrn->ModeSet)

-	pScrn->ModeSet(pScrn);

-}

-

-#ifdef RANDR_12_INTERFACE

-

-#define EDID_ATOM_NAME		"EDID"

-

-/**

- * Set the RandR EDID property

- */

-static void

-xf86OutputSetEDIDProperty (xf86OutputPtr output, void *data, int data_len)

-{

-    Atom edid_atom = MakeAtom(EDID_ATOM_NAME, sizeof(EDID_ATOM_NAME) - 1, TRUE);

-

-    /* This may get called before the RandR resources have been created */

-    if (output->randr_output == NULL)

-	return;

-

-    if (data_len != 0) {

-	RRChangeOutputProperty(output->randr_output, edid_atom, XA_INTEGER, 8,

-			       PropModeReplace, data_len, data, FALSE, TRUE);

-    } else {

-	RRDeleteOutputProperty(output->randr_output, edid_atom);

-    }

-}

-

-#endif

-

-/* Pull out a phyiscal size from a detailed timing if available. */

-struct det_phySize_parameter {

-    xf86OutputPtr output;

-    ddc_quirk_t quirks;

-    Bool ret;

-};

-

-static void  handle_detailed_physical_size(struct detailed_monitor_section

-		                          *det_mon, void *data)

-{

-    struct det_phySize_parameter *p;

-    p = (struct det_phySize_parameter *)data;

-

-    if (p->ret == TRUE )

-        return ;

-

-    xf86DetTimingApplyQuirks(det_mon, p->quirks,

-                             p->output->MonInfo->features.hsize,

-                             p->output->MonInfo->features.vsize);

-    if (det_mon->type == DT &&

-        det_mon->section.d_timings.h_size != 0 &&

-        det_mon->section.d_timings.v_size != 0) {

-

-        p->output->mm_width = det_mon->section.d_timings.h_size;

-        p->output->mm_height = det_mon->section.d_timings.v_size;

-        p->ret = TRUE;

-    }

-}

-

-/**

- * Set the EDID information for the specified output

- */

-void

-xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)

-{

-    ScrnInfoPtr		scrn = output->scrn;

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    Bool		debug_modes = config->debug_modes || xf86Initialising;

-#ifdef RANDR_12_INTERFACE

-    int			size;

-#endif

-    

-    free(output->MonInfo);

-    

-    output->MonInfo = edid_mon;

-    output->mm_width = 0;

-    output->mm_height = 0;

-

-    if (debug_modes) {

-	xf86DrvMsg(scrn->scrnIndex, X_INFO, "EDID for output %s\n",

-		   output->name);

-	xf86PrintEDID(edid_mon);

-    }

-

-    /* Set the DDC properties for the 'compat' output */

-    if (output == xf86CompatOutput(scrn))

-        xf86SetDDCproperties(scrn, edid_mon);

-

-#ifdef RANDR_12_INTERFACE

-    /* Set the RandR output properties */

-    size = 0;

-    if (edid_mon)

-    {

-	if (edid_mon->ver.version == 1) {

-	    size = 128;

-	    if (edid_mon->flags & EDID_COMPLETE_RAWDATA)

-		size += edid_mon->no_sections * 128;

-	} else if (edid_mon->ver.version == 2)

-	    size = 256;

-    }

-    xf86OutputSetEDIDProperty (output, edid_mon ? edid_mon->rawData : NULL, size);

-#endif

-

-    if (edid_mon) {

-

-        struct det_phySize_parameter p;

-        p.output = output;

-        p.quirks = xf86DDCDetectQuirks(scrn->scrnIndex,edid_mon, FALSE);

-        p.ret = FALSE;

-        xf86ForEachDetailedBlock(edid_mon,

-                                 handle_detailed_physical_size, &p);

-

-	/* if no mm size is available from a detailed timing, check the max size field */

-	if ((!output->mm_width || !output->mm_height) &&

-	    (edid_mon->features.hsize && edid_mon->features.vsize))

-	{

-	    output->mm_width = edid_mon->features.hsize * 10;

-	    output->mm_height = edid_mon->features.vsize * 10;

-	}

-    }

-}

-

-/**

- * Return the list of modes supported by the EDID information

- * stored in 'output'

- */

-DisplayModePtr

-xf86OutputGetEDIDModes (xf86OutputPtr output)

-{

-    ScrnInfoPtr	scrn = output->scrn;

-    xf86MonPtr	edid_mon = output->MonInfo;

-

-    if (!edid_mon)

-	return NULL;

-    return xf86DDCGetModes(scrn->scrnIndex, edid_mon);

-}

-

-/* maybe we should care about DDC1?  meh. */

-xf86MonPtr

-xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)

-{

-    ScrnInfoPtr	scrn = output->scrn;

-    xf86MonPtr mon;

-

-    mon = xf86DoEEDID(scrn->scrnIndex, pDDCBus, TRUE);

-    if (mon)

-        xf86DDCApplyQuirks(scrn->scrnIndex, mon);

-

-    return mon;

-}

-

-static char *_xf86ConnectorNames[] = {

-					"None", "VGA", "DVI-I", "DVI-D",

-					"DVI-A", "Composite", "S-Video",

-					"Component", "LFP", "Proprietary",

-					"HDMI", "DisplayPort",

-				     };

-char *

-xf86ConnectorGetName(xf86ConnectorType connector)

-{

-    return _xf86ConnectorNames[connector];

-}

-

-static void

-x86_crtc_box_intersect(BoxPtr dest, BoxPtr a, BoxPtr b)

-{

-    dest->x1 = a->x1 > b->x1 ? a->x1 : b->x1;

-    dest->x2 = a->x2 < b->x2 ? a->x2 : b->x2;

-    dest->y1 = a->y1 > b->y1 ? a->y1 : b->y1;

-    dest->y2 = a->y2 < b->y2 ? a->y2 : b->y2;

-

-    if (dest->x1 >= dest->x2 || dest->y1 >= dest->y2)

-	dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;

-}

-

-static void

-x86_crtc_box(xf86CrtcPtr crtc, BoxPtr crtc_box)

-{

-    if (crtc->enabled) {

-	crtc_box->x1 = crtc->x;

-	crtc_box->x2 = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);

-	crtc_box->y1 = crtc->y;

-	crtc_box->y2 = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);

-    } else

-	crtc_box->x1 = crtc_box->x2 = crtc_box->y1 = crtc_box->y2 = 0;

-}

-

-static int

-xf86_crtc_box_area(BoxPtr box)

-{

-    return (int) (box->x2 - box->x1) * (int) (box->y2 - box->y1);

-}

-

-/*

- * Return the crtc covering 'box'. If two crtcs cover a portion of

- * 'box', then prefer 'desired'. If 'desired' is NULL, then prefer the crtc

- * with greater coverage

- */

-

-static xf86CrtcPtr

-xf86_covering_crtc(ScrnInfoPtr pScrn,

-		   BoxPtr      box,

-		   xf86CrtcPtr desired,

-		   BoxPtr      crtc_box_ret)

-{

-    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);

-    xf86CrtcPtr		crtc, best_crtc;

-    int			coverage, best_coverage;

-    int			c;

-    BoxRec		crtc_box, cover_box;

-

-    best_crtc = NULL;

-    best_coverage = 0;

-    crtc_box_ret->x1 = 0;

-    crtc_box_ret->x2 = 0;

-    crtc_box_ret->y1 = 0;

-    crtc_box_ret->y2 = 0;

-    for (c = 0; c < xf86_config->num_crtc; c++) {

-	crtc = xf86_config->crtc[c];

-	x86_crtc_box(crtc, &crtc_box);

-	x86_crtc_box_intersect(&cover_box, &crtc_box, box);

-	coverage = xf86_crtc_box_area(&cover_box);

-	if (coverage && crtc == desired) {

-	    *crtc_box_ret = crtc_box;

-	    return crtc;

-	} else if (coverage > best_coverage) {

-	    *crtc_box_ret = crtc_box;

-	    best_crtc = crtc;

-	    best_coverage = coverage;

-	}

-    }

-    return best_crtc;

-}

-

-/*

- * For overlay video, compute the relevant CRTC and

- * clip video to that.

- *

- * returning FALSE means there was a memory failure of some kind,

- * not that the video shouldn't be displayed

- */

-

-Bool

-xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,

-			    xf86CrtcPtr *crtc_ret,

-			    xf86CrtcPtr desired_crtc,

-			    BoxPtr      dst,

-			    INT32	*xa,

-			    INT32	*xb,

-			    INT32	*ya,

-			    INT32	*yb,

-			    RegionPtr   reg,

-			    INT32	width,

-			    INT32	height)

-{

-    Bool	ret;

-    RegionRec	crtc_region_local;

-    RegionPtr	crtc_region = reg;

-    

-    if (crtc_ret) {

-	BoxRec		crtc_box;

-	xf86CrtcPtr	crtc = xf86_covering_crtc(pScrn, dst,

-						  desired_crtc,

-						  &crtc_box);

-

-	if (crtc) {

-	    RegionInit(&crtc_region_local, &crtc_box, 1);

-	    crtc_region = &crtc_region_local;

-	    RegionIntersect(crtc_region, crtc_region, reg);

-	}

-	*crtc_ret = crtc;

-    }

-

-    ret = xf86XVClipVideoHelper(dst, xa, xb, ya, yb, 

-				crtc_region, width, height);

-

-    if (crtc_region != reg)

-	RegionUninit(&crtc_region_local);

-

-    return ret;

-}

-

-xf86_crtc_notify_proc_ptr

-xf86_wrap_crtc_notify (ScreenPtr screen, xf86_crtc_notify_proc_ptr new)

-{

-    if (xf86CrtcConfigPrivateIndex != -1)

-    {

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

-	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-	xf86_crtc_notify_proc_ptr	old;

-	

-	old = config->xf86_crtc_notify;

-	config->xf86_crtc_notify = new;

-	return old;

-    }

-    return NULL;

-}

-

-void

-xf86_unwrap_crtc_notify(ScreenPtr screen, xf86_crtc_notify_proc_ptr old)

-{

-    if (xf86CrtcConfigPrivateIndex != -1)

-    {

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

-	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    

-	config->xf86_crtc_notify = old;

-    }

-}

-

-void

-xf86_crtc_notify(ScreenPtr screen)

-{

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

-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);

-    

-    if (config->xf86_crtc_notify)

-	config->xf86_crtc_notify(screen);

-}

-

-Bool

-xf86_crtc_supports_gamma(ScrnInfoPtr pScrn)

-{

-    if (xf86CrtcConfigPrivateIndex != -1) {

-	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);

-	xf86CrtcPtr crtc;

-

-	/* for multiple drivers loaded we need this */

-	if (!xf86_config)

-		return FALSE;

-	if (xf86_config->num_crtc == 0)

-	    return FALSE;

-	crtc = xf86_config->crtc[0];

-

-	return crtc->funcs->gamma_set != NULL;

-    }

-

-    return FALSE;

-}

+/*
+ * Copyright © 2006 Keith Packard
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#else
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#endif
+
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "xf86.h"
+#include "xf86DDC.h"
+#include "xf86Crtc.h"
+#include "xf86Modes.h"
+#include "xf86Priv.h"
+#include "xf86RandR12.h"
+#include "X11/extensions/render.h"
+#include "X11/extensions/dpmsconst.h"
+#include "X11/Xatom.h"
+#include "picturestr.h"
+
+#include "xf86xv.h"
+
+#define NO_OUTPUT_DEFAULT_WIDTH 1024
+#define NO_OUTPUT_DEFAULT_HEIGHT 768
+/*
+ * Initialize xf86CrtcConfig structure
+ */
+
+int xf86CrtcConfigPrivateIndex = -1;
+
+void
+xf86CrtcConfigInit (ScrnInfoPtr scrn,
+		    const xf86CrtcConfigFuncsRec *funcs)
+{
+    xf86CrtcConfigPtr	config;
+    
+    if (xf86CrtcConfigPrivateIndex == -1)
+	xf86CrtcConfigPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
+    config = xnfcalloc (1, sizeof (xf86CrtcConfigRec));
+
+    config->funcs = funcs;
+
+    scrn->privates[xf86CrtcConfigPrivateIndex].ptr = config;
+}
+ 
+void
+xf86CrtcSetSizeRange (ScrnInfoPtr scrn,
+		      int minWidth, int minHeight,
+		      int maxWidth, int maxHeight)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    config->minWidth = minWidth;
+    config->minHeight = minHeight;
+    config->maxWidth = maxWidth;
+    config->maxHeight = maxHeight;
+}
+
+/*
+ * Crtc functions
+ */
+xf86CrtcPtr
+xf86CrtcCreate (ScrnInfoPtr		scrn,
+		const xf86CrtcFuncsRec	*funcs)
+{
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcPtr		crtc, *crtcs;
+
+    crtc = calloc(sizeof (xf86CrtcRec), 1);
+    if (!crtc)
+	return NULL;
+    crtc->version = XF86_CRTC_VERSION;
+    crtc->scrn = scrn;
+    crtc->funcs = funcs;
+#ifdef RANDR_12_INTERFACE
+    crtc->randr_crtc = NULL;
+#endif
+    crtc->rotation = RR_Rotate_0;
+    crtc->desiredRotation = RR_Rotate_0;
+    pixman_transform_init_identity (&crtc->crtc_to_framebuffer);
+    pixman_f_transform_init_identity (&crtc->f_crtc_to_framebuffer);
+    pixman_f_transform_init_identity (&crtc->f_framebuffer_to_crtc);
+    crtc->filter = NULL;
+    crtc->params = NULL;
+    crtc->nparams = 0;
+    crtc->filter_width = 0;
+    crtc->filter_height = 0;
+    crtc->transform_in_use = FALSE;
+    crtc->transformPresent = FALSE;
+    crtc->desiredTransformPresent = FALSE;
+    memset (&crtc->bounds, '\0', sizeof (crtc->bounds));
+
+    /* Preallocate gamma at a sensible size. */
+    crtc->gamma_size = 256;
+    crtc->gamma_red = malloc(3 * crtc->gamma_size * sizeof (CARD16));
+    if (!crtc->gamma_red) {
+	free(crtc);
+	return NULL;
+    }
+    crtc->gamma_green = crtc->gamma_red + crtc->gamma_size;
+    crtc->gamma_blue = crtc->gamma_green + crtc->gamma_size;
+
+    if (xf86_config->crtc)
+	crtcs = realloc(xf86_config->crtc,
+			  (xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));
+    else
+	crtcs = malloc((xf86_config->num_crtc + 1) * sizeof (xf86CrtcPtr));
+    if (!crtcs)
+    {
+	free(crtc->gamma_red);
+	free(crtc);
+	return NULL;
+    }
+    xf86_config->crtc = crtcs;
+    xf86_config->crtc[xf86_config->num_crtc++] = crtc;
+    return crtc;
+}
+
+void
+xf86CrtcDestroy (xf86CrtcPtr crtc)
+{
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
+    int			c;
+    
+    (*crtc->funcs->destroy) (crtc);
+    for (c = 0; c < xf86_config->num_crtc; c++)
+	if (xf86_config->crtc[c] == crtc)
+	{
+	    memmove (&xf86_config->crtc[c],
+		     &xf86_config->crtc[c+1],
+		     ((xf86_config->num_crtc - (c + 1)) * sizeof(void*)));
+	    xf86_config->num_crtc--;
+	    break;
+	}
+    free(crtc->params);
+    free(crtc->gamma_red);
+    free(crtc);
+}
+
+
+/**
+ * Return whether any outputs are connected to the specified pipe
+ */
+
+Bool
+xf86CrtcInUse (xf86CrtcPtr crtc)
+{
+    ScrnInfoPtr		pScrn = crtc->scrn;
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int			o;
+    
+    for (o = 0; o < xf86_config->num_output; o++)
+	if (xf86_config->output[o]->crtc == crtc)
+	    return TRUE;
+    return FALSE;
+}
+
+void
+xf86CrtcSetScreenSubpixelOrder (ScreenPtr pScreen)
+{
+    int			subpixel_order = SubPixelUnknown;
+    Bool		has_none = FALSE;
+    ScrnInfoPtr		scrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			c, o;
+
+    for (c = 0; c < xf86_config->num_crtc; c++)
+    {
+	xf86CrtcPtr crtc = xf86_config->crtc[c];
+	
+	for (o = 0; o < xf86_config->num_output; o++)
+	{
+	    xf86OutputPtr   output = xf86_config->output[o];
+
+	    if (output->crtc == crtc)
+	    {
+		switch (output->subpixel_order) {
+		case SubPixelNone:
+		    has_none = TRUE;
+		    break;
+		case SubPixelUnknown:
+		    break;
+		default:
+		    subpixel_order = output->subpixel_order;
+		    break;
+		}
+	    }
+	    if (subpixel_order != SubPixelUnknown)
+		break;
+	}
+	if (subpixel_order != SubPixelUnknown)
+	{
+	    static const int circle[4] = {
+		SubPixelHorizontalRGB,
+		SubPixelVerticalRGB,
+		SubPixelHorizontalBGR,
+		SubPixelVerticalBGR,
+	    };
+	    int	rotate;
+	    int c;
+	    for (rotate = 0; rotate < 4; rotate++)
+		if (crtc->rotation & (1 << rotate))
+		    break;
+	    for (c = 0; c < 4; c++)
+		if (circle[c] == subpixel_order)
+		    break;
+	    c = (c + rotate) & 0x3;
+	    if ((crtc->rotation & RR_Reflect_X) && !(c & 1))
+		c ^= 2;
+	    if ((crtc->rotation & RR_Reflect_Y) && (c & 1))
+		c ^= 2;
+	    subpixel_order = circle[c];
+	    break;
+	}
+    }
+    if (subpixel_order == SubPixelUnknown && has_none)
+	subpixel_order = SubPixelNone;
+    PictureSetSubpixelOrder (pScreen, subpixel_order);
+}
+
+/**
+ * Sets the given video mode on the given crtc
+ */
+Bool
+xf86CrtcSetModeTransform (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
+			  RRTransformPtr transform, int x, int y)
+{
+    ScrnInfoPtr		scrn = crtc->scrn;
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			i;
+    Bool		ret = FALSE;
+    Bool		didLock = FALSE;
+    DisplayModePtr	adjusted_mode;
+    DisplayModeRec	saved_mode;
+    int			saved_x, saved_y;
+    Rotation		saved_rotation;
+    RRTransformRec	saved_transform;
+    Bool		saved_transform_present;
+
+    crtc->enabled = xf86CrtcInUse (crtc);
+
+    /* We only hit this if someone explicitly sends a "disabled" modeset. */
+    if (!crtc->enabled)
+    {
+	/* Check everything for stuff that should be off. */
+	xf86DisableUnusedFunctions(scrn);
+	return TRUE;
+    }
+
+    adjusted_mode = xf86DuplicateMode(mode);
+
+
+    saved_mode = crtc->mode;
+    saved_x = crtc->x;
+    saved_y = crtc->y;
+    saved_rotation = crtc->rotation;
+    if (crtc->transformPresent) {
+	RRTransformInit (&saved_transform);
+	RRTransformCopy (&saved_transform, &crtc->transform);
+    }
+    saved_transform_present = crtc->transformPresent;
+
+    /* Update crtc values up front so the driver can rely on them for mode
+     * setting.
+     */
+    crtc->mode = *mode;
+    crtc->x = x;
+    crtc->y = y;
+    crtc->rotation = rotation;
+    if (transform) {
+	RRTransformCopy (&crtc->transform, transform);
+	crtc->transformPresent = TRUE;
+    } else
+	crtc->transformPresent = FALSE;
+
+    if (crtc->funcs->set_mode_major) {
+	ret = crtc->funcs->set_mode_major(crtc, mode, rotation, x, y);
+	goto done;
+    }
+
+    didLock = crtc->funcs->lock (crtc);
+    /* Pass our mode to the outputs and the CRTC to give them a chance to
+     * adjust it according to limitations or output properties, and also
+     * a chance to reject the mode entirely.
+     */
+    for (i = 0; i < xf86_config->num_output; i++) {
+	xf86OutputPtr output = xf86_config->output[i];
+
+	if (output->crtc != crtc)
+	    continue;
+
+	if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {
+	    goto done;
+	}
+    }
+
+    if (!crtc->funcs->mode_fixup(crtc, mode, adjusted_mode)) {
+	goto done;
+    }
+
+    if (!xf86CrtcRotate (crtc))
+	goto done;
+
+    /* Prepare the outputs and CRTCs before setting the mode. */
+    for (i = 0; i < xf86_config->num_output; i++) {
+	xf86OutputPtr output = xf86_config->output[i];
+
+	if (output->crtc != crtc)
+	    continue;
+
+	/* Disable the output as the first thing we do. */
+	output->funcs->prepare(output);
+    }
+
+    crtc->funcs->prepare(crtc);
+
+    /* Set up the DPLL and any output state that needs to adjust or depend
+     * on the DPLL.
+     */
+    crtc->funcs->mode_set(crtc, mode, adjusted_mode, crtc->x, crtc->y);
+    for (i = 0; i < xf86_config->num_output; i++) 
+    {
+	xf86OutputPtr output = xf86_config->output[i];
+	if (output->crtc == crtc)
+	    output->funcs->mode_set(output, mode, adjusted_mode);
+    }
+
+    /* Only upload when needed, to avoid unneeded delays. */
+    if (!crtc->active && crtc->funcs->gamma_set)
+	crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
+                                            crtc->gamma_blue, crtc->gamma_size);
+
+    /* Now, enable the clocks, plane, pipe, and outputs that we set up. */
+    crtc->funcs->commit(crtc);
+    for (i = 0; i < xf86_config->num_output; i++) 
+    {
+	xf86OutputPtr output = xf86_config->output[i];
+	if (output->crtc == crtc)
+	    output->funcs->commit(output);
+    }
+
+    ret = TRUE;
+
+done:
+    if (ret) {
+	crtc->active = TRUE;
+	if (scrn->pScreen)
+	    xf86CrtcSetScreenSubpixelOrder (scrn->pScreen);
+	if (scrn->ModeSet)
+	    scrn->ModeSet(scrn);
+    } else {
+	crtc->x = saved_x;
+	crtc->y = saved_y;
+	crtc->rotation = saved_rotation;
+	crtc->mode = saved_mode;
+	if (saved_transform_present)
+	    RRTransformCopy (&crtc->transform, &saved_transform);
+	crtc->transformPresent = saved_transform_present;
+    }
+
+    free(adjusted_mode->name);
+    free(adjusted_mode);
+
+    if (didLock)
+	crtc->funcs->unlock (crtc);
+
+    return ret;
+}
+
+/**
+ * Sets the given video mode on the given crtc, but without providing
+ * a transform
+ */
+Bool
+xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
+		 int x, int y)
+{
+    return xf86CrtcSetModeTransform (crtc, mode, rotation, NULL, x, y);
+}
+
+/**
+ * Pans the screen, does not change the mode
+ */
+void
+xf86CrtcSetOrigin (xf86CrtcPtr crtc, int x, int y)
+{
+    ScrnInfoPtr scrn = crtc->scrn;
+
+    crtc->x = x;
+    crtc->y = y;
+    if (crtc->funcs->set_origin) {
+	if (!xf86CrtcRotate (crtc))
+	    return;
+	crtc->funcs->set_origin (crtc, x, y);
+	if (scrn->ModeSet)
+	    scrn->ModeSet(scrn);
+    }
+    else
+	xf86CrtcSetMode (crtc, &crtc->mode, crtc->rotation, x, y);
+}
+
+/*
+ * Output functions
+ */
+
+extern XF86ConfigPtr xf86configptr;
+
+typedef enum {
+    OPTION_PREFERRED_MODE,
+    OPTION_POSITION,
+    OPTION_BELOW,
+    OPTION_RIGHT_OF,
+    OPTION_ABOVE,
+    OPTION_LEFT_OF,
+    OPTION_ENABLE,
+    OPTION_DISABLE,
+    OPTION_MIN_CLOCK,
+    OPTION_MAX_CLOCK,
+    OPTION_IGNORE,
+    OPTION_ROTATE,
+    OPTION_PANNING,
+    OPTION_PRIMARY,
+    OPTION_DEFAULT_MODES,
+} OutputOpts;
+
+static OptionInfoRec xf86OutputOptions[] = {
+    {OPTION_PREFERRED_MODE, "PreferredMode",	OPTV_STRING,  {0}, FALSE },
+    {OPTION_POSITION,	    "Position",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_BELOW,	    "Below",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_RIGHT_OF,	    "RightOf",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_ABOVE,	    "Above",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_LEFT_OF,	    "LeftOf",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_ENABLE,	    "Enable",		OPTV_BOOLEAN, {0}, FALSE },
+    {OPTION_DISABLE,	    "Disable",		OPTV_BOOLEAN, {0}, FALSE },
+    {OPTION_MIN_CLOCK,	    "MinClock",		OPTV_FREQ,    {0}, FALSE },
+    {OPTION_MAX_CLOCK,	    "MaxClock",		OPTV_FREQ,    {0}, FALSE },
+    {OPTION_IGNORE,	    "Ignore",		OPTV_BOOLEAN, {0}, FALSE },
+    {OPTION_ROTATE,	    "Rotate",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_PANNING,	    "Panning",		OPTV_STRING,  {0}, FALSE },
+    {OPTION_PRIMARY,	    "Primary",		OPTV_BOOLEAN, {0}, FALSE },
+    {OPTION_DEFAULT_MODES,  "DefaultModes",	OPTV_BOOLEAN, {0}, FALSE },
+    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },
+};
+
+enum {
+    OPTION_MODEDEBUG,
+};
+
+static OptionInfoRec xf86DeviceOptions[] = {
+    {OPTION_MODEDEBUG,	    "ModeDebug",	OPTV_BOOLEAN,  {0}, FALSE },
+    {-1,		    NULL,		OPTV_NONE,    {0}, FALSE },
+};
+
+static void
+xf86OutputSetMonitor (xf86OutputPtr output)
+{
+    char    *option_name;
+    char    *monitor;
+
+    if (!output->name)
+	return;
+
+    free(output->options);
+
+    output->options = xnfalloc (sizeof (xf86OutputOptions));
+    memcpy (output->options, xf86OutputOptions, sizeof (xf86OutputOptions));
+
+    XNFasprintf(&option_name, "monitor-%s", output->name);
+    monitor = xf86findOptionValue (output->scrn->options, option_name);
+    if (!monitor)
+	monitor = output->name;
+    else
+	xf86MarkOptionUsedByName (output->scrn->options, option_name);
+    free(option_name);
+    output->conf_monitor = xf86findMonitor (monitor,
+					    xf86configptr->conf_monitor_lst);
+    /*
+     * Find the monitor section of the screen and use that
+     */
+    if (!output->conf_monitor && output->use_screen_monitor)
+	output->conf_monitor = xf86findMonitor (output->scrn->monitor->id,
+						xf86configptr->conf_monitor_lst);
+    if (output->conf_monitor)
+    {
+	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
+		    "Output %s using monitor section %s\n",
+		    output->name, output->conf_monitor->mon_identifier);
+	xf86ProcessOptions (output->scrn->scrnIndex,
+			    output->conf_monitor->mon_option_lst,
+			    output->options);
+    }
+    else
+	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
+		    "Output %s has no monitor section\n",
+		    output->name);
+}
+
+static Bool
+xf86OutputEnabled (xf86OutputPtr output, Bool strict)
+{
+    Bool    enable, disable;
+
+    /* check to see if this output was enabled in the config file */
+    if (xf86GetOptValBool (output->options, OPTION_ENABLE, &enable) && enable)
+    {
+	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
+		    "Output %s enabled by config file\n", output->name);
+	return TRUE;
+    }
+    /* or if this output was disabled in the config file */
+    if (xf86GetOptValBool (output->options, OPTION_DISABLE, &disable) && disable)
+    {
+	xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
+		    "Output %s disabled by config file\n", output->name);
+	return FALSE;
+    }
+
+    /* If not, try to only light up the ones we know are connected */
+    if (strict) {
+	enable = output->status == XF86OutputStatusConnected;
+    }
+    /* But if that fails, try to light up even outputs we're unsure of */
+    else {
+	enable = output->status != XF86OutputStatusDisconnected;
+    }
+
+    xf86DrvMsg (output->scrn->scrnIndex, X_INFO,
+    	    "Output %s %sconnected\n", output->name, enable ? "" : "dis");
+    return enable;
+}
+
+static Bool
+xf86OutputIgnored (xf86OutputPtr    output)
+{
+    return xf86ReturnOptValBool (output->options, OPTION_IGNORE, FALSE);
+}
+
+static char *direction[4] = {
+    "normal", 
+    "left", 
+    "inverted", 
+    "right"
+};
+
+static Rotation
+xf86OutputInitialRotation (xf86OutputPtr output)
+{
+    char    *rotate_name = xf86GetOptValString (output->options, 
+						OPTION_ROTATE);
+    int	    i;
+
+    if (!rotate_name) {
+	if (output->initial_rotation)
+	    return output->initial_rotation;
+	return RR_Rotate_0;
+    }
+    
+    for (i = 0; i < 4; i++)
+	if (xf86nameCompare (direction[i], rotate_name) == 0)
+	    return 1 << i;
+    return RR_Rotate_0;
+}
+
+xf86OutputPtr
+xf86OutputCreate (ScrnInfoPtr		    scrn,
+		  const xf86OutputFuncsRec  *funcs,
+		  const char		    *name)
+{
+    xf86OutputPtr	output, *outputs;
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			len;
+    Bool		primary;
+
+    if (name)
+	len = strlen (name) + 1;
+    else
+	len = 0;
+
+    output = calloc(sizeof (xf86OutputRec) + len, 1);
+    if (!output)
+	return NULL;
+    output->scrn = scrn;
+    output->funcs = funcs;
+    if (name)
+    {
+	output->name = (char *) (output + 1);
+	strcpy (output->name, name);
+    }
+    output->subpixel_order = SubPixelUnknown;
+    /*
+     * Use the old per-screen monitor section for the first output
+     */
+    output->use_screen_monitor = (xf86_config->num_output == 0);
+#ifdef RANDR_12_INTERFACE
+    output->randr_output = NULL;
+#endif
+    if (name)
+    {
+	xf86OutputSetMonitor (output);
+	if (xf86OutputIgnored (output))
+	{
+	    free(output);
+	    return FALSE;
+	}
+    }
+    
+    
+    if (xf86_config->output)
+	outputs = realloc(xf86_config->output,
+			  (xf86_config->num_output + 1) * sizeof (xf86OutputPtr));
+    else
+	outputs = malloc((xf86_config->num_output + 1) * sizeof (xf86OutputPtr));
+    if (!outputs)
+    {
+	free(output);
+	return NULL;
+    }
+
+    xf86_config->output = outputs;
+
+    if (xf86GetOptValBool (output->options, OPTION_PRIMARY, &primary) && primary)
+    {
+	memmove(xf86_config->output + 1, xf86_config->output,
+		xf86_config->num_output * sizeof (xf86OutputPtr));
+	xf86_config->output[0] = output;
+    }
+    else
+    {
+	xf86_config->output[xf86_config->num_output] = output;
+    }
+
+    xf86_config->num_output++;
+
+    return output;
+}
+
+Bool
+xf86OutputRename (xf86OutputPtr output, const char *name)
+{
+    char    *newname = strdup(name);
+    
+    if (!newname)
+	return FALSE;	/* so sorry... */
+    
+    if (output->name && output->name != (char *) (output + 1))
+	free(output->name);
+    output->name = newname;
+    xf86OutputSetMonitor (output);
+    if (xf86OutputIgnored (output))
+	return FALSE;
+    return TRUE;
+}
+
+void
+xf86OutputUseScreenMonitor (xf86OutputPtr output, Bool use_screen_monitor)
+{
+    if (use_screen_monitor != output->use_screen_monitor)
+    {
+	output->use_screen_monitor = use_screen_monitor;
+	xf86OutputSetMonitor (output);
+    }
+}
+
+void
+xf86OutputDestroy (xf86OutputPtr output)
+{
+    ScrnInfoPtr		scrn = output->scrn;
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o;
+    
+    (*output->funcs->destroy) (output);
+    while (output->probed_modes)
+	xf86DeleteMode (&output->probed_modes, output->probed_modes);
+    for (o = 0; o < xf86_config->num_output; o++)
+	if (xf86_config->output[o] == output)
+	{
+	    memmove (&xf86_config->output[o],
+		     &xf86_config->output[o+1],
+		     ((xf86_config->num_output - (o + 1)) * sizeof(void*)));
+	    xf86_config->num_output--;
+	    break;
+	}
+    if (output->name && output->name != (char *) (output + 1))
+	free(output->name);
+    free(output);
+}
+
+/*
+ * Called during CreateScreenResources to hook up RandR
+ */
+static Bool
+xf86CrtcCreateScreenResources (ScreenPtr screen)
+{
+    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    screen->CreateScreenResources = config->CreateScreenResources;
+    
+    if (!(*screen->CreateScreenResources)(screen))
+	return FALSE;
+
+    if (!xf86RandR12CreateScreenResources (screen))
+	return FALSE;
+
+    return TRUE;
+}
+
+/*
+ * Clean up config on server reset
+ */
+static Bool
+xf86CrtcCloseScreen (int index, ScreenPtr screen)
+{
+    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o, c;
+    
+    screen->CloseScreen = config->CloseScreen;
+
+    xf86RotateCloseScreen (screen);
+
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+
+	output->randr_output = NULL;
+    }
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	xf86CrtcPtr	crtc = config->crtc[c];
+
+	crtc->randr_crtc = NULL;
+    }
+    xf86RandR12CloseScreen (screen);
+
+    return screen->CloseScreen (index, screen);
+}
+
+/*
+ * Called at ScreenInit time to set up
+ */
+#ifdef RANDR_13_INTERFACE
+int
+#else
+Bool
+#endif
+xf86CrtcScreenInit (ScreenPtr screen)
+{
+    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			c;
+
+    /* Rotation */
+    xf86DrvMsg(scrn->scrnIndex, X_INFO, "RandR 1.2 enabled, ignore the following RandR disabled message.\n");
+    xf86DisableRandR(); /* Disable old RandR extension support */
+    xf86RandR12Init (screen);
+
+    /* support all rotations if every crtc has the shadow alloc funcs */
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	xf86CrtcPtr crtc = config->crtc[c];
+	if (!crtc->funcs->shadow_allocate || !crtc->funcs->shadow_create)
+	    break;
+    }
+    if (c == config->num_crtc)
+    {
+	xf86RandR12SetRotations (screen, RR_Rotate_0 | RR_Rotate_90 |
+				 RR_Rotate_180 | RR_Rotate_270 |
+				 RR_Reflect_X | RR_Reflect_Y);
+	xf86RandR12SetTransformSupport (screen, TRUE);
+    }
+    else
+    {
+	xf86RandR12SetRotations (screen, RR_Rotate_0);
+	xf86RandR12SetTransformSupport (screen, FALSE);
+    }
+    
+    /* Wrap CreateScreenResources so we can initialize the RandR code */
+    config->CreateScreenResources = screen->CreateScreenResources;
+    screen->CreateScreenResources = xf86CrtcCreateScreenResources;
+
+    config->CloseScreen = screen->CloseScreen;
+    screen->CloseScreen = xf86CrtcCloseScreen;
+    
+#ifdef XFreeXDGA
+    _xf86_di_dga_init_internal(screen);
+#endif
+#ifdef RANDR_13_INTERFACE
+    return RANDR_INTERFACE_VERSION;
+#else
+    return TRUE;
+#endif
+}
+
+static DisplayModePtr
+xf86DefaultMode (xf86OutputPtr output, int width, int height)
+{
+    DisplayModePtr  target_mode = NULL;
+    DisplayModePtr  mode;
+    int		    target_diff = 0;
+    int		    target_preferred = 0;
+    int		    mm_height;
+    
+    mm_height = output->mm_height;
+    if (!mm_height)
+	mm_height = (768 * 25.4) / DEFAULT_DPI;
+    /*
+     * Pick a mode closest to DEFAULT_DPI
+     */
+    for (mode = output->probed_modes; mode; mode = mode->next)
+    {
+	int	    dpi;
+	int	    preferred = (((mode->type & M_T_PREFERRED) != 0) +
+				 ((mode->type & M_T_USERPREF) != 0));
+	int	    diff;
+
+	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
+	    xf86ModeHeight (mode, output->initial_rotation) > height)
+	    continue;
+	
+	/* yes, use VDisplay here, not xf86ModeHeight */
+	dpi = (mode->VDisplay * 254) / (mm_height * 10);
+	diff = dpi - DEFAULT_DPI;
+	diff = diff < 0 ? -diff : diff;
+	if (target_mode == NULL || (preferred > target_preferred) ||
+	    (preferred == target_preferred && diff < target_diff))
+	{
+	    target_mode = mode;
+	    target_diff = diff;
+	    target_preferred = preferred;
+	}
+    }
+    return target_mode;
+}
+
+static DisplayModePtr
+xf86ClosestMode (xf86OutputPtr output, 
+		 DisplayModePtr match, Rotation match_rotation,
+		 int width, int height)
+{
+    DisplayModePtr  target_mode = NULL;
+    DisplayModePtr  mode;
+    int		    target_diff = 0;
+    
+    /*
+     * Pick a mode closest to the specified mode
+     */
+    for (mode = output->probed_modes; mode; mode = mode->next)
+    {
+	int	    dx, dy;
+	int	    diff;
+
+	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
+	    xf86ModeHeight (mode, output->initial_rotation) > height)
+	    continue;
+	
+	/* exact matches are preferred */
+	if (output->initial_rotation == match_rotation &&
+	    xf86ModesEqual (mode, match))
+	    return mode;
+	
+	dx = xf86ModeWidth (match, match_rotation) - xf86ModeWidth (mode, output->initial_rotation);
+	dy = xf86ModeHeight (match, match_rotation) - xf86ModeHeight (mode, output->initial_rotation);
+	diff = dx * dx + dy * dy;
+	if (target_mode == NULL || diff < target_diff)
+	{
+	    target_mode = mode;
+	    target_diff = diff;
+	}
+    }
+    return target_mode;
+}
+
+static DisplayModePtr
+xf86OutputHasPreferredMode (xf86OutputPtr output, int width, int height)
+{
+    DisplayModePtr  mode;
+
+    for (mode = output->probed_modes; mode; mode = mode->next)
+    {
+	if (xf86ModeWidth (mode, output->initial_rotation) > width ||
+	    xf86ModeHeight (mode, output->initial_rotation) > height)
+	    continue;
+
+	if (mode->type & M_T_PREFERRED)
+	    return mode;
+    }
+    return NULL;
+}
+
+static DisplayModePtr
+xf86OutputHasUserPreferredMode (xf86OutputPtr output)
+{
+    DisplayModePtr mode, first = output->probed_modes;
+
+    for (mode = first; mode && mode->next != first; mode = mode->next)
+	if (mode->type & M_T_USERPREF)
+	    return mode;
+
+    return NULL;
+}
+
+static int
+xf86PickCrtcs (ScrnInfoPtr	scrn,
+	       xf86CrtcPtr	*best_crtcs,
+	       DisplayModePtr	*modes,
+	       int		n,
+	       int		width,
+	       int		height)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int		    c, o;
+    xf86OutputPtr   output;
+    xf86CrtcPtr	    crtc;
+    xf86CrtcPtr	    *crtcs;
+    xf86CrtcPtr	    best_crtc;
+    int		    best_score;
+    int		    score;
+    int		    my_score;
+    
+    if (n == config->num_output)
+	return 0;
+    output = config->output[n];
+    
+    /*
+     * Compute score with this output disabled
+     */
+    best_crtcs[n] = NULL;
+    best_crtc = NULL;
+    best_score = xf86PickCrtcs (scrn, best_crtcs, modes, n+1, width, height);
+    if (modes[n] == NULL)
+	return best_score;
+    
+    crtcs = malloc(config->num_output * sizeof (xf86CrtcPtr));
+    if (!crtcs)
+	return best_score;
+
+    my_score = 1;
+    /* Score outputs that are known to be connected higher */
+    if (output->status == XF86OutputStatusConnected)
+	my_score++;
+    /* Score outputs with preferred modes higher */
+    if (xf86OutputHasPreferredMode (output, width, height))
+	my_score++;
+    /*
+     * Select a crtc for this output and
+     * then attempt to configure the remaining
+     * outputs
+     */
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	if ((output->possible_crtcs & (1 << c)) == 0)
+	    continue;
+	
+	crtc = config->crtc[c];
+	/*
+	 * Check to see if some other output is
+	 * using this crtc
+	 */
+	for (o = 0; o < n; o++)
+	    if (best_crtcs[o] == crtc)
+		break;
+	if (o < n)
+	{
+	    /*
+	     * If the two outputs desire the same mode,
+	     * see if they can be cloned
+	     */
+	    if (xf86ModesEqual (modes[o], modes[n]) &&
+		config->output[o]->initial_rotation == config->output[n]->initial_rotation &&
+		config->output[o]->initial_x == config->output[n]->initial_x &&
+		config->output[o]->initial_y == config->output[n]->initial_y)
+	    {
+		if ((output->possible_clones & (1 << o)) == 0)
+		    continue;		/* nope, try next CRTC */
+	    }
+	    else
+		continue;		/* different modes, can't clone */
+	}
+	crtcs[n] = crtc;
+	memcpy (crtcs, best_crtcs, n * sizeof (xf86CrtcPtr));
+	score = my_score + xf86PickCrtcs (scrn, crtcs, modes, n+1, width, height);
+	if (score > best_score)
+	{
+	    best_crtc = crtc;
+	    best_score = score;
+	    memcpy (best_crtcs, crtcs, config->num_output * sizeof (xf86CrtcPtr));
+	}
+    }
+    free(crtcs);
+    return best_score;
+}
+
+
+/*
+ * Compute the virtual size necessary to place all of the available
+ * crtcs in the specified configuration.
+ *
+ * canGrow indicates that the driver can make the screen larger than its initial
+ * configuration.  If FALSE, this function will enlarge the screen to include
+ * the largest available mode.
+ */
+
+static void
+xf86DefaultScreenLimits (ScrnInfoPtr scrn, int *widthp, int *heightp,
+			 Bool canGrow)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int	    width = 0, height = 0;
+    int	    o;
+    int	    c;
+    int	    s;
+
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	int	    crtc_width = 0, crtc_height = 0;
+	xf86CrtcPtr crtc = config->crtc[c];
+
+	if (crtc->enabled)
+	{
+	    crtc_width = crtc->desiredX + xf86ModeWidth (&crtc->desiredMode, crtc->desiredRotation);
+	    crtc_height = crtc->desiredY + xf86ModeHeight (&crtc->desiredMode, crtc->desiredRotation);
+	}
+	if (!canGrow) {
+	    for (o = 0; o < config->num_output; o++)
+	    {
+		xf86OutputPtr   output = config->output[o];
+
+		for (s = 0; s < config->num_crtc; s++)
+		    if (output->possible_crtcs & (1 << s))
+		    {
+			DisplayModePtr  mode;
+			for (mode = output->probed_modes; mode; mode = mode->next)
+			{
+			    if (mode->HDisplay > crtc_width)
+				crtc_width = mode->HDisplay;
+			    if (mode->VDisplay > crtc_width)
+				crtc_width = mode->VDisplay;
+			    if (mode->VDisplay > crtc_height)
+				crtc_height = mode->VDisplay;
+			    if (mode->HDisplay > crtc_height)
+				crtc_height = mode->HDisplay;
+			}
+		    }
+	    }
+	}
+	if (crtc_width > width)
+	    width = crtc_width;
+	if (crtc_height > height)
+	    height = crtc_height;
+    }
+    if (config->maxWidth && width > config->maxWidth) width = config->maxWidth;
+    if (config->maxHeight && height > config->maxHeight) height = config->maxHeight;
+    if (config->minWidth && width < config->minWidth) width = config->minWidth;
+    if (config->minHeight && height < config->minHeight) height = config->minHeight;
+    *widthp = width;
+    *heightp = height;
+}
+
+#define POSITION_UNSET	-100000
+
+/*
+ * check if the user configured any outputs at all 
+ * with either a position or a relative setting or a mode.
+ */
+static Bool
+xf86UserConfiguredOutputs(ScrnInfoPtr scrn, DisplayModePtr *modes)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int o;
+    Bool user_conf = FALSE;
+
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr output = config->output[o];
+	char	    *position;
+	char	    *relative_name;
+	OutputOpts	    relation;
+	int r;
+	static const OutputOpts	relations[] = {
+	    OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
+	};
+
+	position = xf86GetOptValString (output->options,
+					OPTION_POSITION);
+	if (position)
+	    user_conf = TRUE;
+
+	relation = 0;
+	relative_name = NULL;
+	for (r = 0; r < 4; r++)
+	{
+	    relation = relations[r];
+	    relative_name = xf86GetOptValString (output->options,
+						     relation);
+	    if (relative_name)
+		break;
+	}
+	if (relative_name)
+	    user_conf = TRUE;
+
+	modes[o] = xf86OutputHasUserPreferredMode(output);
+	if (modes[o])
+	    user_conf = TRUE;
+    }
+
+    return user_conf;
+}
+
+static Bool
+xf86InitialOutputPositions (ScrnInfoPtr scrn, DisplayModePtr *modes)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o;
+    int			min_x, min_y;
+    
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+
+	output->initial_x = output->initial_y = POSITION_UNSET;
+    }
+    
+    /*
+     * Loop until all outputs are set
+     */
+    for (;;)
+    {
+	Bool	any_set = FALSE;
+	Bool	keep_going = FALSE;
+
+	for (o = 0; o < config->num_output; o++)	
+	{
+	    static const OutputOpts	relations[] = {
+		OPTION_BELOW, OPTION_RIGHT_OF, OPTION_ABOVE, OPTION_LEFT_OF
+	    };
+	    xf86OutputPtr   output = config->output[o];
+	    xf86OutputPtr   relative;
+	    char	    *relative_name;
+	    char	    *position;
+	    OutputOpts	    relation;
+	    int		    r;
+
+	    if (output->initial_x != POSITION_UNSET)
+		continue;
+	    position = xf86GetOptValString (output->options,
+					    OPTION_POSITION);
+	    /*
+	     * Absolute position wins
+	     */
+	    if (position)
+	    {
+		int		    x, y;
+		if (sscanf (position, "%d %d", &x, &y) == 2)
+		{
+		    output->initial_x = x;
+		    output->initial_y = y;
+		}
+		else
+		{
+		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+				"Output %s position not of form \"x y\"\n",
+				output->name);
+		    output->initial_x = output->initial_y = 0;
+		}
+		any_set = TRUE;
+		continue;
+	    }
+	    /*
+	     * Next comes relative positions
+	     */
+	    relation = 0;
+	    relative_name = NULL;
+	    for (r = 0; r < 4; r++)
+	    {
+		relation = relations[r];
+		relative_name = xf86GetOptValString (output->options,
+						     relation);
+		if (relative_name)
+		    break;
+	    }
+	    if (relative_name)
+	    {
+		int or;
+		relative = NULL;
+		for (or = 0; or < config->num_output; or++)
+		{
+		    xf86OutputPtr	out_rel = config->output[or];
+		    XF86ConfMonitorPtr	rel_mon = out_rel->conf_monitor;
+
+		    if (rel_mon)
+		    {
+			if (xf86nameCompare (rel_mon->mon_identifier,
+					      relative_name) == 0)
+			{
+			    relative = config->output[or];
+			    break;
+			}
+		    }
+		    if (strcmp (out_rel->name, relative_name) == 0)
+		    {
+			relative = config->output[or];
+			break;
+		    }
+		}
+		if (!relative)
+		{
+		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+				"Cannot position output %s relative to unknown output %s\n",
+				output->name, relative_name);
+		    output->initial_x = 0;
+		    output->initial_y = 0;
+		    any_set = TRUE;
+		    continue;
+		}
+		if (!modes[or])
+		{
+		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+				"Cannot position output %s relative to output %s without modes\n",
+				output->name, relative_name);
+		    output->initial_x = 0;
+		    output->initial_y = 0;
+		    any_set = TRUE;
+		    continue;
+		}
+		if (relative->initial_x == POSITION_UNSET)
+		{
+		    keep_going = TRUE;
+		    continue;
+		}
+		output->initial_x = relative->initial_x;
+		output->initial_y = relative->initial_y;
+		switch (relation) {
+		case OPTION_BELOW:
+		    output->initial_y += xf86ModeHeight (modes[or], relative->initial_rotation);
+		    break;
+		case OPTION_RIGHT_OF:
+		    output->initial_x += xf86ModeWidth (modes[or], relative->initial_rotation);
+		    break;
+		case OPTION_ABOVE:
+		    if (modes[o])
+			output->initial_y -= xf86ModeHeight (modes[o], output->initial_rotation);
+		    break;
+		case OPTION_LEFT_OF:
+		    if (modes[o])
+			output->initial_x -= xf86ModeWidth (modes[o], output->initial_rotation);
+		    break;
+		default:
+		    break;
+		}
+		any_set = TRUE;
+		continue;
+	    }
+	    
+	    /* Nothing set, just stick them at 0,0 */
+	    output->initial_x = 0;
+	    output->initial_y = 0;
+	    any_set = TRUE;
+	}
+	if (!keep_going)
+	    break;
+	if (!any_set) 
+	{
+	    for (o = 0; o < config->num_output; o++)
+	    {
+		xf86OutputPtr   output = config->output[o];
+		if (output->initial_x == POSITION_UNSET)
+		{
+		    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+				"Output position loop. Moving %s to 0,0\n",
+				output->name);
+		    output->initial_x = output->initial_y = 0;
+		    break;
+		}
+	    }
+	}
+    }
+
+    /*
+     * normalize positions
+     */
+    min_x = 1000000;
+    min_y = 1000000;
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+
+	if (output->initial_x < min_x)
+	    min_x = output->initial_x;
+	if (output->initial_y < min_y)
+	    min_y = output->initial_y;
+    }
+    
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+
+	output->initial_x -= min_x;
+	output->initial_y -= min_y;
+    }
+    return TRUE;
+}
+
+static void
+xf86InitialPanning (ScrnInfoPtr scrn)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o;
+    
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+	char	       *panning = xf86GetOptValString (output->options, OPTION_PANNING);
+	int		width, height, left, top;
+	int		track_width, track_height, track_left, track_top;
+	int		brdr[4];
+
+	memset (&output->initialTotalArea,    0, sizeof(BoxRec));
+	memset (&output->initialTrackingArea, 0, sizeof(BoxRec));
+	memset (output->initialBorder,        0, 4*sizeof(INT16));
+
+	if (! panning)
+	    continue;
+
+	switch (sscanf (panning, "%dx%d+%d+%d/%dx%d+%d+%d/%d/%d/%d/%d",
+			&width, &height, &left, &top,
+			&track_width, &track_height, &track_left, &track_top,
+			&brdr[0], &brdr[1], &brdr[2], &brdr[3])) {
+	case 12:
+	    output->initialBorder[0] = brdr[0];
+	    output->initialBorder[1] = brdr[1];
+	    output->initialBorder[2] = brdr[2];
+	    output->initialBorder[3] = brdr[3];
+	    /* fall through */
+	case 8:
+	    output->initialTrackingArea.x1 = track_left;
+	    output->initialTrackingArea.y1 = track_top;
+	    output->initialTrackingArea.x2 = track_left + track_width;
+	    output->initialTrackingArea.y2 = track_top  + track_height;
+	    /* fall through */
+	case 4:
+	    output->initialTotalArea.x1 = left;
+	    output->initialTotalArea.y1 = top;
+	    /* fall through */
+	case 2:
+	    output->initialTotalArea.x2 = output->initialTotalArea.x1 + width;
+	    output->initialTotalArea.y2 = output->initialTotalArea.y1 + height;
+	    break;
+	default:
+	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+			"Broken panning specification '%s' for output %s in config file\n",
+			panning, output->name);
+	}
+    }
+}
+
+/** Return - 0 + if a should be earlier, same or later than b in list
+ */
+static int
+xf86ModeCompare (DisplayModePtr a, DisplayModePtr b)
+{
+    int	diff;
+
+    diff = ((b->type & M_T_PREFERRED) != 0) - ((a->type & M_T_PREFERRED) != 0);
+    if (diff)
+	return diff;
+    diff = b->HDisplay * b->VDisplay - a->HDisplay * a->VDisplay;
+    if (diff)
+	return diff;
+    diff = b->Clock - a->Clock;
+    return diff;
+}
+
+/**
+ * Insertion sort input in-place and return the resulting head
+ */
+static DisplayModePtr
+xf86SortModes (DisplayModePtr input)
+{
+    DisplayModePtr  output = NULL, i, o, n, *op, prev;
+
+    /* sort by preferred status and pixel area */
+    while (input)
+    {
+	i = input;
+	input = input->next;
+	for (op = &output; (o = *op); op = &o->next)
+	    if (xf86ModeCompare (o, i) > 0)
+		break;
+	i->next = *op;
+	*op = i;
+    }
+    /* prune identical modes */
+    for (o = output; o && (n = o->next); o = n)
+    {
+	if (!strcmp (o->name, n->name) && xf86ModesEqual (o, n))
+	{
+	    o->next = n->next;
+	    free(n->name);
+	    free(n);
+	    n = o;
+	}
+    }
+    /* hook up backward links */
+    prev = NULL;
+    for (o = output; o; o = o->next)
+    {
+	o->prev = prev;
+	prev = o;
+    }
+    return output;
+}
+
+static char *
+preferredMode(ScrnInfoPtr pScrn, xf86OutputPtr output)
+{
+    char *preferred_mode = NULL;
+
+    /* Check for a configured preference for a particular mode */
+    preferred_mode = xf86GetOptValString (output->options,
+					  OPTION_PREFERRED_MODE);
+    if (preferred_mode)
+	return preferred_mode;
+
+    if (pScrn->display->modes && *pScrn->display->modes)
+	preferred_mode = *pScrn->display->modes;
+
+    return preferred_mode;
+}
+
+static void
+GuessRangeFromModes(MonPtr mon, DisplayModePtr mode)
+{
+    if (!mon || !mode)
+       return;
+
+    mon->nHsync = 1;
+    mon->hsync[0].lo = 1024.0;
+    mon->hsync[0].hi = 0.0;
+
+    mon->nVrefresh = 1;
+    mon->vrefresh[0].lo = 1024.0;
+    mon->vrefresh[0].hi = 0.0;
+
+    while (mode) {
+	if (!mode->HSync)
+	    mode->HSync = ((float) mode->Clock ) / ((float) mode->HTotal);
+
+	if (!mode->VRefresh)
+	    mode->VRefresh = (1000.0 * ((float) mode->Clock)) / 
+		((float) (mode->HTotal * mode->VTotal));
+
+	if (mode->HSync < mon->hsync[0].lo)
+	    mon->hsync[0].lo = mode->HSync;
+
+	if (mode->HSync > mon->hsync[0].hi)
+	    mon->hsync[0].hi = mode->HSync;
+
+	if (mode->VRefresh < mon->vrefresh[0].lo)
+	    mon->vrefresh[0].lo = mode->VRefresh;
+
+	if (mode->VRefresh > mon->vrefresh[0].hi)
+	    mon->vrefresh[0].hi = mode->VRefresh;
+
+	mode = mode->next;
+    }
+
+    /* stretch out the bottom to fit 640x480@60 */
+    if (mon->hsync[0].lo > 31.0)
+       mon->hsync[0].lo = 31.0;
+    if (mon->vrefresh[0].lo > 58.0)
+       mon->vrefresh[0].lo = 58.0;
+}
+
+enum det_monrec_source {
+    sync_config, sync_edid, sync_default
+};
+
+struct det_monrec_parameter {
+    MonRec *mon_rec;
+    int *max_clock;
+    Bool set_hsync;
+    Bool set_vrefresh;
+    enum det_monrec_source *sync_source;
+};
+
+static void handle_detailed_monrec(struct detailed_monitor_section *det_mon,
+                                   void *data)
+{
+    struct det_monrec_parameter *p;
+    p = (struct det_monrec_parameter *)data;
+
+    if (det_mon->type == DS_RANGES) {
+        struct monitor_ranges *ranges = &det_mon->section.ranges;
+        if (p->set_hsync && ranges->max_h) {
+            p->mon_rec->hsync[p->mon_rec->nHsync].lo = ranges->min_h;
+            p->mon_rec->hsync[p->mon_rec->nHsync].hi = ranges->max_h;
+            p->mon_rec->nHsync++;
+            if (*p->sync_source == sync_default)
+                *p->sync_source = sync_edid;
+        }
+        if (p->set_vrefresh && ranges->max_v) {
+            p->mon_rec->vrefresh[p->mon_rec->nVrefresh].lo = ranges->min_v;
+            p->mon_rec->vrefresh[p->mon_rec->nVrefresh].hi = ranges->max_v;
+            p->mon_rec->nVrefresh++;
+            if (*p->sync_source == sync_default)
+                *p->sync_source = sync_edid;
+        }
+        if (ranges->max_clock * 1000 > *p->max_clock)
+            *p->max_clock = ranges->max_clock * 1000;
+    }
+}
+
+void
+xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o;
+
+    /* When canGrow was TRUE in the initial configuration we have to
+     * compare against the maximum values so that we don't drop modes.
+     * When canGrow was FALSE, the maximum values would have been clamped
+     * anyway.
+     */
+    if (maxX == 0 || maxY == 0) {
+	maxX = config->maxWidth;
+	maxY = config->maxHeight;
+    }
+
+    /* Probe the list of modes for each output. */
+    for (o = 0; o < config->num_output; o++) 
+    {
+	xf86OutputPtr	    output = config->output[o];
+	DisplayModePtr	    mode;
+	DisplayModePtr	    config_modes = NULL, output_modes, default_modes = NULL;
+	char		    *preferred_mode;
+	xf86MonPtr	    edid_monitor;
+	XF86ConfMonitorPtr  conf_monitor;
+	MonRec		    mon_rec;
+	int		    min_clock = 0;
+	int		    max_clock = 0;
+	double		    clock;
+	Bool		    add_default_modes;
+	Bool		    debug_modes = config->debug_modes ||
+					  xf86Initialising;
+	enum det_monrec_source sync_source = sync_default;
+	
+	while (output->probed_modes != NULL)
+	    xf86DeleteMode(&output->probed_modes, output->probed_modes);
+
+	/*
+	 * Check connection status
+	 */
+	output->status = (*output->funcs->detect)(output);
+
+	if (output->status == XF86OutputStatusDisconnected &&
+		!xf86ReturnOptValBool(output->options, OPTION_ENABLE, FALSE))
+	{
+	    xf86OutputSetEDID (output, NULL);
+	    continue;
+	}
+
+	memset (&mon_rec, '\0', sizeof (mon_rec));
+	
+	conf_monitor = output->conf_monitor;
+	
+	if (conf_monitor)
+	{
+	    int	i;
+	    
+	    for (i = 0; i < conf_monitor->mon_n_hsync; i++)
+	    {
+		mon_rec.hsync[mon_rec.nHsync].lo = conf_monitor->mon_hsync[i].lo;
+		mon_rec.hsync[mon_rec.nHsync].hi = conf_monitor->mon_hsync[i].hi;
+		mon_rec.nHsync++;
+		sync_source = sync_config;
+	    }
+	    for (i = 0; i < conf_monitor->mon_n_vrefresh; i++)
+	    {
+		mon_rec.vrefresh[mon_rec.nVrefresh].lo = conf_monitor->mon_vrefresh[i].lo;
+		mon_rec.vrefresh[mon_rec.nVrefresh].hi = conf_monitor->mon_vrefresh[i].hi;
+		mon_rec.nVrefresh++;
+		sync_source = sync_config;
+	    }
+	    config_modes = xf86GetMonitorModes (scrn, conf_monitor);
+	}
+	
+	output_modes = (*output->funcs->get_modes) (output);
+
+	/*
+	 * If the user has a preference, respect it.
+	 * Otherwise, don't second-guess the driver.
+	 */
+	if (!xf86GetOptValBool(output->options, OPTION_DEFAULT_MODES,
+			       &add_default_modes))
+	    add_default_modes = (output_modes == NULL);
+	
+	edid_monitor = output->MonInfo;
+	
+        if (edid_monitor)
+        {
+            struct det_monrec_parameter p;
+            struct disp_features    *features = &edid_monitor->features;
+
+	    /* if display is not continuous-frequency, don't add default modes */
+	    if (!GTF_SUPPORTED(features->msc))
+		add_default_modes = FALSE;
+
+	    p.mon_rec = &mon_rec;
+	    p.max_clock = &max_clock;
+	    p.set_hsync = mon_rec.nHsync == 0;
+	    p.set_vrefresh = mon_rec.nVrefresh == 0;
+	    p.sync_source = &sync_source;
+
+	    xf86ForEachDetailedBlock(edid_monitor,
+			             handle_detailed_monrec,
+			             &p);
+	}
+
+	if (xf86GetOptValFreq (output->options, OPTION_MIN_CLOCK,
+			       OPTUNITS_KHZ, &clock))
+	    min_clock = (int) clock;
+	if (xf86GetOptValFreq (output->options, OPTION_MAX_CLOCK,
+			       OPTUNITS_KHZ, &clock))
+	    max_clock = (int) clock;
+
+	/* If we still don't have a sync range, guess wildly */
+	if (!mon_rec.nHsync || !mon_rec.nVrefresh)
+	    GuessRangeFromModes(&mon_rec, output_modes);
+
+	/*
+	 * These limits will end up setting a 1024x768@60Hz mode by default,
+	 * which seems like a fairly good mode to use when nothing else is
+	 * specified
+	 */
+	if (mon_rec.nHsync == 0)
+	{
+	    mon_rec.hsync[0].lo = 31.0;
+	    mon_rec.hsync[0].hi = 55.0;
+	    mon_rec.nHsync = 1;
+	}
+	if (mon_rec.nVrefresh == 0)
+	{
+	    mon_rec.vrefresh[0].lo = 58.0;
+	    mon_rec.vrefresh[0].hi = 62.0;
+	    mon_rec.nVrefresh = 1;
+	}
+
+	if (add_default_modes)
+	    default_modes = xf86GetDefaultModes ();
+
+	/*
+	 * If this is not an RB monitor, remove RB modes from the default
+	 * pool.  RB modes from the config or the monitor itself are fine.
+	 */
+	if (!mon_rec.reducedblanking)
+	    xf86ValidateModesReducedBlanking (scrn, default_modes);
+
+	if (sync_source == sync_config)
+	{
+	    /* 
+	     * Check output and config modes against sync range from config file
+	     */
+	    xf86ValidateModesSync (scrn, output_modes, &mon_rec);
+	    xf86ValidateModesSync (scrn, config_modes, &mon_rec);
+	}
+	/*
+	 * Check default modes against sync range
+	 */
+        xf86ValidateModesSync (scrn, default_modes, &mon_rec);
+	/*
+	 * Check default modes against monitor max clock
+	 */
+	if (max_clock) {
+	    xf86ValidateModesClocks(scrn, default_modes,
+				    &min_clock, &max_clock, 1);
+	    xf86ValidateModesClocks(scrn, output_modes,
+				    &min_clock, &max_clock, 1);
+	}
+	
+	output->probed_modes = NULL;
+	output->probed_modes = xf86ModesAdd (output->probed_modes, config_modes);
+	output->probed_modes = xf86ModesAdd (output->probed_modes, output_modes);
+	output->probed_modes = xf86ModesAdd (output->probed_modes, default_modes);
+	
+	/*
+	 * Check all modes against max size, interlace, and doublescan
+	 */
+	if (maxX && maxY)
+	    xf86ValidateModesSize (scrn, output->probed_modes,
+				       maxX, maxY, 0);
+
+	{
+	    int flags = (output->interlaceAllowed ? V_INTERLACE : 0) |
+			(output->doubleScanAllowed ? V_DBLSCAN : 0);
+	    xf86ValidateModesFlags (scrn, output->probed_modes, flags);
+	}
+	 
+	/*
+	 * Check all modes against output
+	 */
+	for (mode = output->probed_modes; mode != NULL; mode = mode->next) 
+	    if (mode->status == MODE_OK)
+		mode->status = (*output->funcs->mode_valid)(output, mode);
+	
+	xf86PruneInvalidModes(scrn, &output->probed_modes, debug_modes);
+	
+	output->probed_modes = xf86SortModes (output->probed_modes);
+	
+	/* Check for a configured preference for a particular mode */
+	preferred_mode = preferredMode(scrn, output);
+
+	if (preferred_mode)
+	{
+	    for (mode = output->probed_modes; mode; mode = mode->next)
+	    {
+		if (!strcmp (preferred_mode, mode->name))
+		{
+		    if (mode != output->probed_modes)
+		    {
+			if (mode->prev)
+			    mode->prev->next = mode->next;
+			if (mode->next)
+			    mode->next->prev = mode->prev;
+			mode->next = output->probed_modes;
+			output->probed_modes->prev = mode;
+			mode->prev = NULL;
+			output->probed_modes = mode;
+		    }
+		    mode->type |= (M_T_PREFERRED|M_T_USERPREF);
+		    break;
+		}
+	    }
+	}
+	
+	output->initial_rotation = xf86OutputInitialRotation (output);
+
+	if (debug_modes) {
+	    if (output->probed_modes != NULL) {
+		xf86DrvMsg(scrn->scrnIndex, X_INFO,
+			   "Printing probed modes for output %s\n",
+			   output->name);
+	    } else {
+		xf86DrvMsg(scrn->scrnIndex, X_INFO,
+			   "No remaining probed modes for output %s\n",
+			   output->name);
+	    }
+	}
+	for (mode = output->probed_modes; mode != NULL; mode = mode->next)
+	{
+	    /* The code to choose the best mode per pipe later on will require
+	     * VRefresh to be set.
+	     */
+	    mode->VRefresh = xf86ModeVRefresh(mode);
+	    xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
+
+	    if (debug_modes)
+		xf86PrintModeline(scrn->scrnIndex, mode);
+	}
+    }
+}
+
+
+/**
+ * Copy one of the output mode lists to the ScrnInfo record
+ */
+
+/* XXX where does this function belong? Here? */
+void
+xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr scrn, int *x, int *y);
+
+static DisplayModePtr
+biggestMode(DisplayModePtr a, DisplayModePtr b)
+{
+    int A, B;
+
+    if (!a)
+	return b;
+    if (!b)
+	return a;
+
+    A = a->HDisplay * a->VDisplay;
+    B = b->HDisplay * b->VDisplay;
+
+    if (A > B)
+	return a;
+
+    return b;
+}
+
+static xf86OutputPtr
+SetCompatOutput(xf86CrtcConfigPtr config)
+{
+    xf86OutputPtr output = NULL, test = NULL;
+    DisplayModePtr maxmode = NULL, testmode, mode;
+    int o, compat = -1, count, mincount = 0;
+
+    /* Look for one that's definitely connected */
+    for (o = 0; o < config->num_output; o++)
+    {
+	test = config->output[o];
+	if (!test->crtc)
+	    continue;
+	if (test->status != XF86OutputStatusConnected)
+	    continue;
+	if (!test->probed_modes)
+	    continue;
+
+	testmode = mode = test->probed_modes;
+	for (count = 0; mode; mode = mode->next, count++)
+	    testmode = biggestMode(testmode, mode);
+
+	if (!output) {
+	    output = test;
+	    compat = o;
+	    maxmode = testmode;
+	    mincount = count;
+	} else if (maxmode == biggestMode(maxmode, testmode)) {
+	    output = test;
+	    compat = o;
+	    maxmode = testmode;
+	    mincount = count;
+	} else if ((maxmode->HDisplay == testmode->HDisplay) && 
+		(maxmode->VDisplay == testmode->VDisplay) &&
+		count <= mincount) {
+	    output = test;
+	    compat = o;
+	    maxmode = testmode;
+	    mincount = count;
+	}
+    }
+
+    /* If we didn't find one, take anything we can get */
+    if (!output)
+    {
+	for (o = 0; o < config->num_output; o++)
+	{
+	    test = config->output[o];
+	    if (!test->crtc)
+		continue;
+	    if (!test->probed_modes)
+		continue;
+
+	    if (!output) {
+		output = test;
+		compat = o;
+	    } else if (test->probed_modes->HDisplay < output->probed_modes->HDisplay) {
+		output = test;
+		compat = o;
+	    }
+	}
+    }
+
+    if (compat >= 0) {
+	config->compat_output = compat;
+    } else {
+	/* Don't change the compat output when no valid outputs found */
+	output = config->output[config->compat_output];
+    }
+
+    return output;
+}
+
+void
+xf86SetScrnInfoModes (ScrnInfoPtr scrn)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86OutputPtr	output;
+    xf86CrtcPtr		crtc;
+    DisplayModePtr	last, mode = NULL;
+
+    output = SetCompatOutput(config);
+
+    if (!output)
+	return; /* punt */
+
+    crtc = output->crtc;
+
+    /* Clear any existing modes from scrn->modes */
+    while (scrn->modes != NULL)
+	xf86DeleteMode(&scrn->modes, scrn->modes);
+
+    /* Set scrn->modes to the mode list for the 'compat' output */
+    scrn->modes = xf86DuplicateModes(scrn, output->probed_modes);
+
+    if (crtc) {
+	for (mode = scrn->modes; mode; mode = mode->next)
+	    if (xf86ModesEqual (mode, &crtc->desiredMode))
+		break;
+    }
+
+    if (scrn->modes != NULL) {
+	/* For some reason, scrn->modes is circular, unlike the other mode
+	 * lists.  How great is that?
+	 */
+	for (last = scrn->modes; last && last->next; last = last->next)
+	    ;
+	last->next = scrn->modes;
+	scrn->modes->prev = last;
+	if (mode) {
+	    while (scrn->modes != mode)
+		scrn->modes = scrn->modes->next;
+	}
+    }
+    scrn->currentMode = scrn->modes;
+#ifdef XFreeXDGA
+    if (scrn->pScreen)
+	    _xf86_di_dga_reinit_internal(scrn->pScreen);
+#endif
+}
+
+static Bool
+xf86CollectEnabledOutputs(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
+			  Bool *enabled)
+{
+    Bool any_enabled = FALSE;
+    int o;
+
+    for (o = 0; o < config->num_output; o++)
+	any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], TRUE);
+    
+    if (!any_enabled) {
+	xf86DrvMsg(scrn->scrnIndex, X_WARNING,
+		   "No outputs definitely connected, trying again...\n");
+
+	for (o = 0; o < config->num_output; o++)
+	    any_enabled |= enabled[o] = xf86OutputEnabled(config->output[o], FALSE);
+    }
+
+    return any_enabled;
+}
+
+static Bool
+nextEnabledOutput(xf86CrtcConfigPtr config, Bool *enabled, int *index)
+{
+    int o = *index;
+
+    for (o++; o < config->num_output; o++) {
+	if (enabled[o]) {
+	    *index = o;
+	    return TRUE;
+	}
+    }
+    
+    return FALSE;
+}
+
+static Bool
+aspectMatch(float a, float b)
+{
+    return fabs(1 - (a / b)) < 0.05;
+}
+
+static DisplayModePtr
+nextAspectMode(xf86OutputPtr o, DisplayModePtr last, float aspect)
+{
+    DisplayModePtr m = NULL;
+
+    if (!o)
+	return NULL;
+
+    if (!last)
+	m = o->probed_modes;
+    else
+	m = last->next;
+
+    for (; m; m = m->next)
+	if (aspectMatch(aspect, (float)m->HDisplay / (float)m->VDisplay))
+	    return m;
+
+    return NULL;
+}
+
+static DisplayModePtr
+bestModeForAspect(xf86CrtcConfigPtr config, Bool *enabled, float aspect)
+{
+    int o = -1, p;
+    DisplayModePtr mode = NULL, test = NULL, match = NULL;
+
+    if (!nextEnabledOutput(config, enabled, &o))
+	return NULL;
+    while ((mode = nextAspectMode(config->output[o], mode, aspect))) {
+	test = mode;
+	for (p = o; nextEnabledOutput(config, enabled, &p); ) {
+	    test = xf86OutputFindClosestMode(config->output[p], mode);
+	    if (!test)
+		break;
+	    if (test->HDisplay != mode->HDisplay ||
+		    test->VDisplay != mode->VDisplay) {
+		test = NULL;
+		break;
+	    }
+	}
+
+	/* if we didn't match it on all outputs, try the next one */
+	if (!test)
+	    continue;
+
+	/* if it's bigger than the last one, save it */
+	if (!match || (test->HDisplay > match->HDisplay))
+	    match = test;
+    }
+
+    /* return the biggest one found */
+    return match;
+}
+
+static Bool
+xf86TargetPreferred(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
+		    DisplayModePtr *modes, Bool *enabled,
+		    int width, int height)
+{
+    int o, p;
+    int max_pref_width = 0, max_pref_height = 0;
+    DisplayModePtr *preferred, *preferred_match;
+    Bool ret = FALSE;
+
+    preferred = xnfcalloc(config->num_output, sizeof(DisplayModePtr));
+    preferred_match = xnfcalloc(config->num_output, sizeof(DisplayModePtr));
+
+    /* Check if the preferred mode is available on all outputs */
+    for (p = -1; nextEnabledOutput(config, enabled, &p); ) {
+	Rotation r = config->output[p]->initial_rotation;
+	DisplayModePtr mode;
+	if ((preferred[p] = xf86OutputHasPreferredMode(config->output[p],
+			width, height))) {
+	    int pref_width = xf86ModeWidth(preferred[p], r);
+	    int pref_height = xf86ModeHeight(preferred[p], r);
+	    Bool all_match = TRUE;
+
+	    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+		Bool match = FALSE;
+		xf86OutputPtr output = config->output[o];
+		if (o == p)
+		    continue;
+
+		for (mode = output->probed_modes; mode; mode = mode->next) {
+		    Rotation r = output->initial_rotation;
+		    if (xf86ModeWidth(mode, r) == pref_width &&
+			    xf86ModeHeight(mode, r) == pref_height) {
+			preferred[o] = mode;
+			match = TRUE;
+		    }
+		}
+
+		all_match &= match;
+	    }
+
+	    if (all_match &&
+		    (pref_width*pref_height > max_pref_width*max_pref_height)) {
+		for (o = -1; nextEnabledOutput(config, enabled, &o); )
+		    preferred_match[o] = preferred[o];
+		max_pref_width = pref_width;
+		max_pref_height = pref_height;
+		ret = TRUE;
+	    }
+	}
+    }
+
+    /*
+     * If there's no preferred mode, but only one monitor, pick the
+     * biggest mode for its aspect ratio, assuming one exists.
+     */
+    if (!ret) do {
+	int i = 0;
+	float aspect = 0.0;
+
+	/* count the number of enabled outputs */
+	for (i = 0, p = -1; nextEnabledOutput(config, enabled, &p); i++) ;
+
+	if (i != 1)
+	    break;
+
+	p = -1;
+	nextEnabledOutput(config, enabled, &p);
+	if (config->output[p]->mm_height)
+	    aspect = (float)config->output[p]->mm_width /
+		     (float)config->output[p]->mm_height;
+
+	if (aspect)
+	    preferred_match[p] = bestModeForAspect(config, enabled, aspect);
+
+	if (preferred_match[p])
+	    ret = TRUE;
+
+    } while (0);
+
+    if (ret) {
+	/* oh good, there is a match.  stash the selected modes and return. */
+	memcpy(modes, preferred_match,
+		config->num_output * sizeof(DisplayModePtr));
+    }
+
+    free(preferred);
+    free(preferred_match);
+    return ret;
+}
+
+static Bool
+xf86TargetAspect(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
+		 DisplayModePtr *modes, Bool *enabled,
+		 int width, int height)
+{
+    int o;
+    float aspect = 0.0, *aspects;
+    xf86OutputPtr output;
+    Bool ret = FALSE;
+    DisplayModePtr guess = NULL, aspect_guess = NULL, base_guess = NULL;
+
+    aspects = xnfcalloc(config->num_output, sizeof(float));
+
+    /* collect the aspect ratios */
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	output = config->output[o];
+	if (output->mm_height)
+	    aspects[o] = (float)output->mm_width / (float)output->mm_height;
+	else
+	    aspects[o] = 4.0 / 3.0;
+    }
+
+    /* check that they're all the same */
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	output = config->output[o];
+	if (!aspect) {
+	    aspect = aspects[o];
+	} else if (!aspectMatch(aspect, aspects[o])) {
+	    goto no_aspect_match;
+	}
+    }
+
+    /* if they're all 4:3, just skip ahead and save effort */
+    if (!aspectMatch(aspect, 4.0/3.0))
+	aspect_guess = bestModeForAspect(config, enabled, aspect);
+
+no_aspect_match:
+    base_guess = bestModeForAspect(config, enabled, 4.0/3.0);
+
+    guess = biggestMode(base_guess, aspect_guess);
+
+    if (!guess)
+	goto out;
+
+    /* found a mode that works everywhere, now apply it */
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	modes[o] = xf86OutputFindClosestMode(config->output[o], guess);
+    }
+    ret = TRUE;
+
+out:
+    free(aspects);
+    return ret;
+}
+
+static Bool
+xf86TargetFallback(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
+		   DisplayModePtr *modes, Bool *enabled,
+		   int width, int height)
+{
+    DisplayModePtr target_mode = NULL;
+    Rotation target_rotation = RR_Rotate_0;
+    DisplayModePtr default_mode;
+    int default_preferred, target_preferred = 0, o;
+
+    /* User preferred > preferred > other modes */
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	default_mode = xf86DefaultMode (config->output[o], width, height);
+	if (!default_mode)
+	    continue;
+
+	default_preferred = (((default_mode->type & M_T_PREFERRED) != 0) +
+		((default_mode->type & M_T_USERPREF) != 0));
+
+	if (default_preferred > target_preferred || !target_mode) {
+	    target_mode = default_mode;
+	    target_preferred = default_preferred;
+	    target_rotation = config->output[o]->initial_rotation;
+	    config->compat_output = o;
+	}
+    }
+
+    if (target_mode)
+	modes[config->compat_output] = target_mode;
+
+    /* Fill in other output modes */
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	if (!modes[o])
+	    modes[o] = xf86ClosestMode(config->output[o], target_mode,
+				       target_rotation, width, height);
+    }
+
+    return target_mode != NULL;
+}
+
+static Bool
+xf86TargetUserpref(ScrnInfoPtr scrn, xf86CrtcConfigPtr config,
+		   DisplayModePtr *modes, Bool *enabled,
+		   int width, int height)
+{
+    int o;
+
+    if (xf86UserConfiguredOutputs(scrn, modes))
+	return xf86TargetFallback(scrn, config, modes, enabled, width, height);
+    
+    for (o = -1; nextEnabledOutput(config, enabled, &o); )
+	if (xf86OutputHasUserPreferredMode(config->output[o]))
+	    return 
+		xf86TargetFallback(scrn, config, modes, enabled, width, height);
+
+    return FALSE;
+}
+
+static Bool
+xf86CrtcSetInitialGamma(xf86CrtcPtr crtc, float gamma_red, float gamma_green,
+        float gamma_blue)
+{
+    int i, size = 256;
+    CARD16 *red, *green, *blue;
+
+    red = malloc(3 * size * sizeof(CARD16));
+    green = red + size;
+    blue = green + size;
+
+     /* Only cause warning if user wanted gamma to be set. */
+    if (!crtc->funcs->gamma_set && (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0)) {
+        free(red);
+        return FALSE;
+    } else if (!crtc->funcs->gamma_set) {
+        free(red);
+        return TRUE;
+      }
+
+    /* At this early stage none of the randr-interface stuff is up.
+     * So take the default gamma size for lack of something better.
+     */
+    for (i = 0; i < size; i++) {
+        if (gamma_red == 1.0)
+            red[i] = i << 8;
+        else
+            red[i] = (CARD16)(pow((double)i/(double)(size - 1),
+			1. / (double)gamma_red) * (double)(size - 1) * 256);
+
+        if (gamma_green == 1.0)
+            green[i] = i << 8;
+        else
+            green[i] = (CARD16)(pow((double)i/(double)(size - 1),
+			1. / (double)gamma_green) * (double)(size - 1) * 256);
+
+        if (gamma_blue == 1.0)
+            blue[i] = i << 8;
+        else
+            blue[i] = (CARD16)(pow((double)i/(double)(size - 1),
+			1. / (double)gamma_blue) * (double)(size - 1) * 256);
+    }
+
+    /* Default size is 256, so anything else is failure. */
+    if (size != crtc->gamma_size) {
+        free(red);
+        return FALSE;
+      }
+
+    crtc->gamma_size = size;
+    memcpy (crtc->gamma_red, red, crtc->gamma_size * sizeof (CARD16));
+    memcpy (crtc->gamma_green, green, crtc->gamma_size * sizeof (CARD16));
+    memcpy (crtc->gamma_blue, blue, crtc->gamma_size * sizeof (CARD16));
+
+    /* Do not set gamma now, delay until the crtc is activated. */
+
+    free(red);
+
+    return TRUE;
+}
+
+static Bool
+xf86OutputSetInitialGamma(xf86OutputPtr output)
+{
+    XF86ConfMonitorPtr mon = output->conf_monitor;
+    float gamma_red = 1.0, gamma_green = 1.0, gamma_blue = 1.0;
+    
+    if (!mon)
+        return TRUE;
+
+    if (!output->crtc)
+        return FALSE;
+
+    /* Get configured values, where they exist. */
+    if (mon->mon_gamma_red >= GAMMA_MIN &&
+        mon->mon_gamma_red <= GAMMA_MAX)
+            gamma_red = mon->mon_gamma_red;
+
+    if (mon->mon_gamma_green >= GAMMA_MIN &&
+        mon->mon_gamma_green <= GAMMA_MAX)
+            gamma_green = mon->mon_gamma_green;
+
+    if (mon->mon_gamma_blue >= GAMMA_MIN &&
+        mon->mon_gamma_blue <= GAMMA_MAX)
+            gamma_blue = mon->mon_gamma_blue;
+
+    /* This avoids setting gamma 1.0 in case another cloned output on this crtc has a specific gamma. */
+    if (gamma_red != 1.0 || gamma_green != 1.0 || gamma_blue != 1.0) {
+	xf86DrvMsg(output->scrn->scrnIndex, X_INFO, "Output %s wants gamma correction (%.1f, %.1f, %.1f)\n", output->name, gamma_red, gamma_green, gamma_blue);
+	return xf86CrtcSetInitialGamma(output->crtc, gamma_red, gamma_green, gamma_blue);
+    }else
+	return TRUE;
+}
+
+/**
+ * Construct default screen configuration
+ *
+ * Given auto-detected (and, eventually, configured) values,
+ * construct a usable configuration for the system
+ *
+ * canGrow indicates that the driver can resize the screen to larger than its
+ * initially configured size via the config->funcs->resize hook.  If TRUE, this
+ * function will set virtualX and virtualY to match the initial configuration
+ * and leave config->max{Width,Height} alone.  If FALSE, it will bloat
+ * virtual[XY] to include the largest modes and set config->max{Width,Height}
+ * accordingly.
+ */
+
+Bool
+xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o, c;
+    xf86CrtcPtr		*crtcs;
+    DisplayModePtr	*modes;
+    Bool		*enabled;
+    int			width, height;
+    int			i = scrn->scrnIndex;
+    Bool have_outputs = TRUE;
+    Bool ret;
+    Bool success = FALSE;
+
+    /* Set up the device options */
+    config->options = xnfalloc (sizeof (xf86DeviceOptions));
+    memcpy (config->options, xf86DeviceOptions, sizeof (xf86DeviceOptions));
+    xf86ProcessOptions (scrn->scrnIndex,
+			scrn->options,
+			config->options);
+    config->debug_modes = xf86ReturnOptValBool (config->options,
+						OPTION_MODEDEBUG, FALSE);
+
+    if (scrn->display->virtualX)
+	width = scrn->display->virtualX;
+    else
+	width = config->maxWidth;
+    if (scrn->display->virtualY)
+	height = scrn->display->virtualY;
+    else
+	height = config->maxHeight;
+
+    xf86ProbeOutputModes (scrn, width, height);
+
+    crtcs = xnfcalloc (config->num_output, sizeof (xf86CrtcPtr));
+    modes = xnfcalloc (config->num_output, sizeof (DisplayModePtr));
+    enabled = xnfcalloc (config->num_output, sizeof (Bool));
+    
+    ret = xf86CollectEnabledOutputs(scrn, config, enabled);
+    if (ret == FALSE && canGrow) {
+	xf86DrvMsg(i, X_WARNING, "Unable to find connected outputs - setting %dx%d initial framebuffer\n",
+		   NO_OUTPUT_DEFAULT_WIDTH, NO_OUTPUT_DEFAULT_HEIGHT);
+	have_outputs = FALSE;
+    } else {
+	if (xf86TargetUserpref(scrn, config, modes, enabled, width, height))
+	    xf86DrvMsg(i, X_INFO, "Using user preference for initial modes\n");
+	else if (xf86TargetPreferred(scrn, config, modes, enabled, width, height))
+	    xf86DrvMsg(i, X_INFO, "Using exact sizes for initial modes\n");
+	else if (xf86TargetAspect(scrn, config, modes, enabled, width, height))
+	    xf86DrvMsg(i, X_INFO, "Using fuzzy aspect match for initial modes\n");
+	else if (xf86TargetFallback(scrn, config, modes, enabled, width, height))
+	    xf86DrvMsg(i, X_INFO, "Using sloppy heuristic for initial modes\n");
+	else
+	    xf86DrvMsg(i, X_WARNING, "Unable to find initial modes\n");
+    }
+
+    for (o = -1; nextEnabledOutput(config, enabled, &o); ) {
+	if (!modes[o])
+	    xf86DrvMsg (scrn->scrnIndex, X_ERROR,
+			"Output %s enabled but has no modes\n",
+			config->output[o]->name);
+	else
+	    xf86DrvMsg (scrn->scrnIndex, X_INFO,
+			"Output %s using initial mode %s\n",
+			config->output[o]->name, modes[o]->name);
+    }
+
+    /*
+     * Set the position of each output
+     */
+    if (!xf86InitialOutputPositions (scrn, modes))
+	goto bailout;
+
+    /*
+     * Set initial panning of each output
+     */
+    xf86InitialPanning (scrn);
+	
+    /*
+     * Assign CRTCs to fit output configuration
+     */
+    if (have_outputs && !xf86PickCrtcs (scrn, crtcs, modes, 0, width, height))
+	goto bailout;
+    
+    /* XXX override xf86 common frame computation code */
+    
+    scrn->display->frameX0 = 0;
+    scrn->display->frameY0 = 0;
+    
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	xf86CrtcPtr	crtc = config->crtc[c];
+
+	crtc->enabled = FALSE;
+	memset (&crtc->desiredMode, '\0', sizeof (crtc->desiredMode));
+	/* Set default gamma for all crtc's. */
+	/* This is done to avoid problems later on with cloned outputs. */
+	xf86CrtcSetInitialGamma(crtc, 1.0, 1.0, 1.0);
+    }
+
+    if (xf86_crtc_supports_gamma(scrn))
+	xf86DrvMsg(scrn->scrnIndex, X_INFO, "Using default gamma of (1.0, 1.0, 1.0) unless otherwise stated.\n");
+
+    /*
+     * Set initial configuration
+     */
+    for (o = 0; o < config->num_output; o++)
+    {
+	xf86OutputPtr	output = config->output[o];
+	DisplayModePtr	mode = modes[o];
+        xf86CrtcPtr	crtc = crtcs[o];
+
+	if (mode && crtc)
+	{
+	    crtc->desiredMode = *mode;
+	    crtc->desiredRotation = output->initial_rotation;
+	    crtc->desiredX = output->initial_x;
+	    crtc->desiredY = output->initial_y;
+	    crtc->desiredTransformPresent = FALSE;
+	    crtc->enabled = TRUE;
+	    memcpy (&crtc->panningTotalArea,    &output->initialTotalArea,    sizeof(BoxRec));
+	    memcpy (&crtc->panningTrackingArea, &output->initialTrackingArea, sizeof(BoxRec));
+	    memcpy (crtc->panningBorder,        output->initialBorder,        4*sizeof(INT16));
+	    output->crtc = crtc;
+	    if (!xf86OutputSetInitialGamma(output))
+		xf86DrvMsg (scrn->scrnIndex, X_WARNING, "Initial gamma correction for output %s: failed.\n", output->name);
+	} else {
+	    output->crtc = NULL;
+	}
+    }
+
+    if (scrn->display->virtualX == 0)
+    {
+	/*
+	 * Expand virtual size to cover the current config and potential mode
+	 * switches, if the driver can't enlarge the screen later.
+	 */
+	xf86DefaultScreenLimits (scrn, &width, &height, canGrow);
+    
+	if (have_outputs == FALSE) {
+	    if (width < NO_OUTPUT_DEFAULT_WIDTH && height < NO_OUTPUT_DEFAULT_HEIGHT) {
+		width = NO_OUTPUT_DEFAULT_WIDTH;
+		height = NO_OUTPUT_DEFAULT_HEIGHT;
+	    }
+	}
+
+	scrn->display->virtualX = width;
+	scrn->display->virtualY = height;
+    }
+
+    if (width > scrn->virtualX)
+	scrn->virtualX = width;
+    if (height > scrn->virtualY)
+	scrn->virtualY = height;
+
+    /*
+     * Make sure the configuration isn't too small.
+     */
+    if (width < config->minWidth || height < config->minHeight)
+	goto bailout;
+
+    /*
+     * Limit the crtc config to virtual[XY] if the driver can't grow the
+     * desktop.
+     */
+    if (!canGrow)
+    {
+	xf86CrtcSetSizeRange (scrn, config->minWidth, config->minHeight,
+			      width, height);
+    }
+
+    if (have_outputs) {
+	/* Mirror output modes to scrn mode list */
+	xf86SetScrnInfoModes (scrn);
+    } else {
+	/* Clear any existing modes from scrn->modes */
+	while (scrn->modes != NULL)
+	    xf86DeleteMode(&scrn->modes, scrn->modes);
+	scrn->modes = xf86ModesAdd(scrn->modes,
+				   xf86CVTMode(width, height, 60, 0, 0));
+    }
+
+    success = TRUE;
+ bailout:
+    free(crtcs);
+    free(modes);
+    free(enabled);
+    return success;
+}
+
+/*
+ * Check the CRTC we're going to map each output to vs. it's current
+ * CRTC.  If they don't match, we have to disable the output and the CRTC
+ * since the driver will have to re-route things.
+ */
+static void
+xf86PrepareOutputs (ScrnInfoPtr scrn)
+{
+    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			o;
+
+    for (o = 0; o < config->num_output; o++) {
+	xf86OutputPtr output = config->output[o];
+#if RANDR_GET_CRTC_INTERFACE
+	/* Disable outputs that are unused or will be re-routed */
+	if (!output->funcs->get_crtc ||
+	    output->crtc != (*output->funcs->get_crtc)(output) ||
+	    output->crtc == NULL)
+#endif
+	    (*output->funcs->dpms)(output, DPMSModeOff);
+    }
+}
+
+static void
+xf86PrepareCrtcs (ScrnInfoPtr scrn)
+{
+    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			c;
+
+    for (c = 0; c < config->num_crtc; c++) {
+#if RANDR_GET_CRTC_INTERFACE
+	xf86CrtcPtr	crtc = config->crtc[c];
+	xf86OutputPtr	output = NULL;
+	uint32_t	desired_outputs = 0, current_outputs = 0;
+	int		o;
+
+	for (o = 0; o < config->num_output; o++) {
+	    output = config->output[o];
+	    if (output->crtc == crtc)
+		desired_outputs |= (1<<o);
+	    /* If we can't tell where it's mapped, force it off */
+	    if (!output->funcs->get_crtc) {
+		desired_outputs = 0;
+		break;
+	    }
+	    if ((*output->funcs->get_crtc)(output) == crtc)
+		current_outputs |= (1<<o);
+	}
+
+	/*
+	 * If mappings are different or the CRTC is unused,
+	 * we need to disable it
+	 */
+	if (desired_outputs != current_outputs ||
+	    !desired_outputs)
+	    (*crtc->funcs->dpms)(crtc, DPMSModeOff);
+#else
+	(*crtc->funcs->dpms)(crtc, DPMSModeOff);
+#endif
+    }
+}
+
+/*
+ * Using the desired mode information in each crtc, set
+ * modes (used in EnterVT functions, or at server startup)
+ */
+
+Bool
+xf86SetDesiredModes (ScrnInfoPtr scrn)
+{
+    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CrtcPtr         crtc = config->crtc[0];
+    int			c;
+
+    /* A driver with this hook will take care of this */
+    if (!crtc->funcs->set_mode_major) {
+	xf86PrepareOutputs(scrn);
+	xf86PrepareCrtcs(scrn);
+    }
+
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	xf86OutputPtr	output = NULL;
+	int		o;
+	RRTransformPtr	transform;
+
+	crtc = config->crtc[c];
+
+	/* Skip disabled CRTCs */
+	if (!crtc->enabled)
+	    continue;
+
+	if (xf86CompatOutput(scrn) && xf86CompatCrtc(scrn) == crtc)
+	    output = xf86CompatOutput(scrn);
+	else
+	{
+	    for (o = 0; o < config->num_output; o++)
+		if (config->output[o]->crtc == crtc)
+		{
+		    output = config->output[o];
+		    break;
+		}
+	}
+	/* paranoia */
+	if (!output)
+	    continue;
+
+	/* Mark that we'll need to re-set the mode for sure */
+	memset(&crtc->mode, 0, sizeof(crtc->mode));
+	if (!crtc->desiredMode.CrtcHDisplay)
+	{
+	    DisplayModePtr  mode = xf86OutputFindClosestMode (output, scrn->currentMode);
+
+	    if (!mode)
+		return FALSE;
+	    crtc->desiredMode = *mode;
+	    crtc->desiredRotation = RR_Rotate_0;
+	    crtc->desiredTransformPresent = FALSE;
+	    crtc->desiredX = 0;
+	    crtc->desiredY = 0;
+	}
+
+	if (crtc->desiredTransformPresent)
+	    transform = &crtc->desiredTransform;
+	else
+	    transform = NULL;
+	if (!xf86CrtcSetModeTransform (crtc, &crtc->desiredMode, crtc->desiredRotation,
+				       transform, crtc->desiredX, crtc->desiredY))
+	    return FALSE;
+    }
+
+    xf86DisableUnusedFunctions(scrn);
+    return TRUE;
+}
+
+/**
+ * In the current world order, there are lists of modes per output, which may
+ * or may not include the mode that was asked to be set by XFree86's mode
+ * selection.  Find the closest one, in the following preference order:
+ *
+ * - Equality
+ * - Closer in size to the requested mode, but no larger
+ * - Closer in refresh rate to the requested mode.
+ */
+
+DisplayModePtr
+xf86OutputFindClosestMode (xf86OutputPtr output, DisplayModePtr desired)
+{
+    DisplayModePtr	best = NULL, scan = NULL;
+
+    for (scan = output->probed_modes; scan != NULL; scan = scan->next) 
+    {
+	/* If there's an exact match, we're done. */
+	if (xf86ModesEqual(scan, desired)) {
+	    best = desired;
+	    break;
+	}
+
+	/* Reject if it's larger than the desired mode. */
+	if (scan->HDisplay > desired->HDisplay || 
+	    scan->VDisplay > desired->VDisplay)
+	{
+	    continue;
+	}
+
+	/*
+	 * If we haven't picked a best mode yet, use the first
+	 * one in the size range
+	 */
+	if (best == NULL) 
+	{
+	    best = scan;
+	    continue;
+	}
+
+	/* Find if it's closer to the right size than the current best
+	 * option.
+	 */
+	if ((scan->HDisplay > best->HDisplay &&
+	     scan->VDisplay >= best->VDisplay) ||
+	    (scan->HDisplay >= best->HDisplay &&
+	     scan->VDisplay > best->VDisplay))
+	{
+	    best = scan;
+	    continue;
+	}
+
+	/* Find if it's still closer to the right refresh than the current
+	 * best resolution.
+	 */
+	if (scan->HDisplay == best->HDisplay &&
+	    scan->VDisplay == best->VDisplay &&
+	    (fabs(scan->VRefresh - desired->VRefresh) <
+	     fabs(best->VRefresh - desired->VRefresh))) {
+	    best = scan;
+	}
+    }
+    return best;
+}
+
+/**
+ * When setting a mode through XFree86-VidModeExtension or XFree86-DGA,
+ * take the specified mode and apply it to the crtc connected to the compat
+ * output. Then, find similar modes for the other outputs, as with the
+ * InitialConfiguration code above. The goal is to clone the desired
+ * mode across all outputs that are currently active.
+ */
+
+Bool
+xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);
+    Bool		ok = TRUE;
+    xf86OutputPtr	compat_output;
+    DisplayModePtr	compat_mode = NULL;
+    int			c;
+
+    /*
+     * Let the compat output drive the final mode selection
+     */
+    compat_output = xf86CompatOutput(pScrn);
+    if (compat_output)
+	compat_mode = xf86OutputFindClosestMode (compat_output, desired);
+    if (compat_mode)
+	desired = compat_mode;
+    
+    for (c = 0; c < config->num_crtc; c++)
+    {
+	xf86CrtcPtr	crtc = config->crtc[c];
+	DisplayModePtr	crtc_mode = NULL;
+	int		o;
+
+	if (!crtc->enabled)
+	    continue;
+	
+	for (o = 0; o < config->num_output; o++)
+	{
+	    xf86OutputPtr   output = config->output[o];
+	    DisplayModePtr  output_mode;
+
+	    /* skip outputs not on this crtc */
+	    if (output->crtc != crtc)
+		continue;
+	    
+	    if (crtc_mode)
+	    {
+		output_mode = xf86OutputFindClosestMode (output, crtc_mode);
+		if (output_mode != crtc_mode)
+		    output->crtc = NULL;
+	    }
+	    else
+		crtc_mode = xf86OutputFindClosestMode (output, desired);
+	}
+	if (!crtc_mode)
+	{
+	    crtc->enabled = FALSE;
+	    continue;
+	}
+	if (!xf86CrtcSetModeTransform (crtc, crtc_mode, rotation, NULL, 0, 0))
+	    ok = FALSE;
+	else
+	{
+	    crtc->desiredMode = *crtc_mode;
+	    crtc->desiredRotation = rotation;
+	    crtc->desiredTransformPresent = FALSE;
+	    crtc->desiredX = 0;
+	    crtc->desiredY = 0;
+	}
+    }
+    xf86DisableUnusedFunctions(pScrn);
+#ifdef RANDR_12_INTERFACE
+    xf86RandR12TellChanged (pScrn->pScreen);
+#endif
+    return ok;
+}
+
+
+/**
+ * Set the DPMS power mode of all outputs and CRTCs.
+ *
+ * If the new mode is off, it will turn off outputs and then CRTCs.
+ * Otherwise, it will affect CRTCs before outputs.
+ */
+void
+xf86DPMSSet(ScrnInfoPtr scrn, int mode, int flags)
+{
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    int			i;
+
+    if (!scrn->vtSema)
+	return;
+
+    if (mode == DPMSModeOff) {
+	for (i = 0; i < config->num_output; i++) {
+	    xf86OutputPtr output = config->output[i];
+	    if (output->crtc != NULL)
+		(*output->funcs->dpms) (output, mode);
+	}
+    }
+
+    for (i = 0; i < config->num_crtc; i++) {
+	xf86CrtcPtr crtc = config->crtc[i];
+	if (crtc->enabled)
+	    (*crtc->funcs->dpms) (crtc, mode);
+    }
+
+    if (mode != DPMSModeOff) {
+	for (i = 0; i < config->num_output; i++) {
+	    xf86OutputPtr output = config->output[i];
+	    if (output->crtc != NULL)
+		(*output->funcs->dpms) (output, mode);
+	}
+    }
+}
+
+/**
+ * Implement the screensaver by just calling down into the driver DPMS hooks.
+ *
+ * Even for monitors with no DPMS support, by the definition of our DPMS hooks,
+ * the outputs will still get disabled (blanked).
+ */
+Bool
+xf86SaveScreen(ScreenPtr pScreen, int mode)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+    if (xf86IsUnblank(mode))
+	xf86DPMSSet(pScrn, DPMSModeOn, 0);
+    else
+	xf86DPMSSet(pScrn, DPMSModeOff, 0);
+
+    return TRUE;
+}
+
+/**
+ * Disable all inactive crtcs and outputs
+ */
+void
+xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)
+{
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int			o, c;
+
+    for (o = 0; o < xf86_config->num_output; o++) 
+    {
+	xf86OutputPtr  output = xf86_config->output[o];
+	if (!output->crtc) 
+	    (*output->funcs->dpms)(output, DPMSModeOff);
+    }
+
+    for (c = 0; c < xf86_config->num_crtc; c++) 
+    {
+	xf86CrtcPtr crtc = xf86_config->crtc[c];
+
+	if (!crtc->enabled) 
+	{
+	    crtc->funcs->dpms(crtc, DPMSModeOff);
+	    memset(&crtc->mode, 0, sizeof(crtc->mode));
+	    xf86RotateDestroy(crtc);
+	    crtc->active = FALSE;
+	}
+    }
+    if (pScrn->pScreen)
+	xf86_crtc_notify(pScrn->pScreen);
+    if (pScrn->ModeSet)
+	pScrn->ModeSet(pScrn);
+}
+
+#ifdef RANDR_12_INTERFACE
+
+#define EDID_ATOM_NAME		"EDID"
+
+/**
+ * Set the RandR EDID property
+ */
+static void
+xf86OutputSetEDIDProperty (xf86OutputPtr output, void *data, int data_len)
+{
+    Atom edid_atom = MakeAtom(EDID_ATOM_NAME, sizeof(EDID_ATOM_NAME) - 1, TRUE);
+
+    /* This may get called before the RandR resources have been created */
+    if (output->randr_output == NULL)
+	return;
+
+    if (data_len != 0) {
+	RRChangeOutputProperty(output->randr_output, edid_atom, XA_INTEGER, 8,
+			       PropModeReplace, data_len, data, FALSE, TRUE);
+    } else {
+	RRDeleteOutputProperty(output->randr_output, edid_atom);
+    }
+}
+
+#endif
+
+/* Pull out a phyiscal size from a detailed timing if available. */
+struct det_phySize_parameter {
+    xf86OutputPtr output;
+    ddc_quirk_t quirks;
+    Bool ret;
+};
+
+static void  handle_detailed_physical_size(struct detailed_monitor_section
+		                          *det_mon, void *data)
+{
+    struct det_phySize_parameter *p;
+    p = (struct det_phySize_parameter *)data;
+
+    if (p->ret == TRUE )
+        return ;
+
+    xf86DetTimingApplyQuirks(det_mon, p->quirks,
+                             p->output->MonInfo->features.hsize,
+                             p->output->MonInfo->features.vsize);
+    if (det_mon->type == DT &&
+        det_mon->section.d_timings.h_size != 0 &&
+        det_mon->section.d_timings.v_size != 0) {
+
+        p->output->mm_width = det_mon->section.d_timings.h_size;
+        p->output->mm_height = det_mon->section.d_timings.v_size;
+        p->ret = TRUE;
+    }
+}
+
+/**
+ * Set the EDID information for the specified output
+ */
+void
+xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)
+{
+    ScrnInfoPtr		scrn = output->scrn;
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    Bool		debug_modes = config->debug_modes || xf86Initialising;
+#ifdef RANDR_12_INTERFACE
+    int			size;
+#endif
+    
+    free(output->MonInfo);
+    
+    output->MonInfo = edid_mon;
+    output->mm_width = 0;
+    output->mm_height = 0;
+
+    if (debug_modes) {
+	xf86DrvMsg(scrn->scrnIndex, X_INFO, "EDID for output %s\n",
+		   output->name);
+	xf86PrintEDID(edid_mon);
+    }
+
+    /* Set the DDC properties for the 'compat' output */
+    if (output == xf86CompatOutput(scrn))
+        xf86SetDDCproperties(scrn, edid_mon);
+
+#ifdef RANDR_12_INTERFACE
+    /* Set the RandR output properties */
+    size = 0;
+    if (edid_mon)
+    {
+	if (edid_mon->ver.version == 1) {
+	    size = 128;
+	    if (edid_mon->flags & EDID_COMPLETE_RAWDATA)
+		size += edid_mon->no_sections * 128;
+	} else if (edid_mon->ver.version == 2)
+	    size = 256;
+    }
+    xf86OutputSetEDIDProperty (output, edid_mon ? edid_mon->rawData : NULL, size);
+#endif
+
+    if (edid_mon) {
+
+        struct det_phySize_parameter p;
+        p.output = output;
+        p.quirks = xf86DDCDetectQuirks(scrn->scrnIndex,edid_mon, FALSE);
+        p.ret = FALSE;
+        xf86ForEachDetailedBlock(edid_mon,
+                                 handle_detailed_physical_size, &p);
+
+	/* if no mm size is available from a detailed timing, check the max size field */
+	if ((!output->mm_width || !output->mm_height) &&
+	    (edid_mon->features.hsize && edid_mon->features.vsize))
+	{
+	    output->mm_width = edid_mon->features.hsize * 10;
+	    output->mm_height = edid_mon->features.vsize * 10;
+	}
+    }
+}
+
+/**
+ * Return the list of modes supported by the EDID information
+ * stored in 'output'
+ */
+DisplayModePtr
+xf86OutputGetEDIDModes (xf86OutputPtr output)
+{
+    ScrnInfoPtr	scrn = output->scrn;
+    xf86MonPtr	edid_mon = output->MonInfo;
+
+    if (!edid_mon)
+	return NULL;
+    return xf86DDCGetModes(scrn->scrnIndex, edid_mon);
+}
+
+/* maybe we should care about DDC1?  meh. */
+xf86MonPtr
+xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)
+{
+    ScrnInfoPtr	scrn = output->scrn;
+    xf86MonPtr mon;
+
+    mon = xf86DoEEDID(scrn->scrnIndex, pDDCBus, TRUE);
+    if (mon)
+        xf86DDCApplyQuirks(scrn->scrnIndex, mon);
+
+    return mon;
+}
+
+static char *_xf86ConnectorNames[] = {
+					"None", "VGA", "DVI-I", "DVI-D",
+					"DVI-A", "Composite", "S-Video",
+					"Component", "LFP", "Proprietary",
+					"HDMI", "DisplayPort",
+				     };
+char *
+xf86ConnectorGetName(xf86ConnectorType connector)
+{
+    return _xf86ConnectorNames[connector];
+}
+
+static void
+x86_crtc_box_intersect(BoxPtr dest, BoxPtr a, BoxPtr b)
+{
+    dest->x1 = a->x1 > b->x1 ? a->x1 : b->x1;
+    dest->x2 = a->x2 < b->x2 ? a->x2 : b->x2;
+    dest->y1 = a->y1 > b->y1 ? a->y1 : b->y1;
+    dest->y2 = a->y2 < b->y2 ? a->y2 : b->y2;
+
+    if (dest->x1 >= dest->x2 || dest->y1 >= dest->y2)
+	dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;
+}
+
+static void
+x86_crtc_box(xf86CrtcPtr crtc, BoxPtr crtc_box)
+{
+    if (crtc->enabled) {
+	crtc_box->x1 = crtc->x;
+	crtc_box->x2 = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
+	crtc_box->y1 = crtc->y;
+	crtc_box->y2 = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);
+    } else
+	crtc_box->x1 = crtc_box->x2 = crtc_box->y1 = crtc_box->y2 = 0;
+}
+
+static int
+xf86_crtc_box_area(BoxPtr box)
+{
+    return (int) (box->x2 - box->x1) * (int) (box->y2 - box->y1);
+}
+
+/*
+ * Return the crtc covering 'box'. If two crtcs cover a portion of
+ * 'box', then prefer 'desired'. If 'desired' is NULL, then prefer the crtc
+ * with greater coverage
+ */
+
+static xf86CrtcPtr
+xf86_covering_crtc(ScrnInfoPtr pScrn,
+		   BoxPtr      box,
+		   xf86CrtcPtr desired,
+		   BoxPtr      crtc_box_ret)
+{
+    xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    xf86CrtcPtr		crtc, best_crtc;
+    int			coverage, best_coverage;
+    int			c;
+    BoxRec		crtc_box, cover_box;
+
+    best_crtc = NULL;
+    best_coverage = 0;
+    crtc_box_ret->x1 = 0;
+    crtc_box_ret->x2 = 0;
+    crtc_box_ret->y1 = 0;
+    crtc_box_ret->y2 = 0;
+    for (c = 0; c < xf86_config->num_crtc; c++) {
+	crtc = xf86_config->crtc[c];
+	x86_crtc_box(crtc, &crtc_box);
+	x86_crtc_box_intersect(&cover_box, &crtc_box, box);
+	coverage = xf86_crtc_box_area(&cover_box);
+	if (coverage && crtc == desired) {
+	    *crtc_box_ret = crtc_box;
+	    return crtc;
+	} else if (coverage > best_coverage) {
+	    *crtc_box_ret = crtc_box;
+	    best_crtc = crtc;
+	    best_coverage = coverage;
+	}
+    }
+    return best_crtc;
+}
+
+/*
+ * For overlay video, compute the relevant CRTC and
+ * clip video to that.
+ *
+ * returning FALSE means there was a memory failure of some kind,
+ * not that the video shouldn't be displayed
+ */
+
+Bool
+xf86_crtc_clip_video_helper(ScrnInfoPtr pScrn,
+			    xf86CrtcPtr *crtc_ret,
+			    xf86CrtcPtr desired_crtc,
+			    BoxPtr      dst,
+			    INT32	*xa,
+			    INT32	*xb,
+			    INT32	*ya,
+			    INT32	*yb,
+			    RegionPtr   reg,
+			    INT32	width,
+			    INT32	height)
+{
+    Bool	ret;
+    RegionRec	crtc_region_local;
+    RegionPtr	crtc_region = reg;
+    
+    if (crtc_ret) {
+	BoxRec		crtc_box;
+	xf86CrtcPtr	crtc = xf86_covering_crtc(pScrn, dst,
+						  desired_crtc,
+						  &crtc_box);
+
+	if (crtc) {
+	    RegionInit(&crtc_region_local, &crtc_box, 1);
+	    crtc_region = &crtc_region_local;
+	    RegionIntersect(crtc_region, crtc_region, reg);
+	}
+	*crtc_ret = crtc;
+    }
+
+    ret = xf86XVClipVideoHelper(dst, xa, xb, ya, yb, 
+				crtc_region, width, height);
+
+    if (crtc_region != reg)
+	RegionUninit(&crtc_region_local);
+
+    return ret;
+}
+
+xf86_crtc_notify_proc_ptr
+xf86_wrap_crtc_notify (ScreenPtr screen, xf86_crtc_notify_proc_ptr new)
+{
+    if (xf86CrtcConfigPrivateIndex != -1)
+    {
+	ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+	xf86_crtc_notify_proc_ptr	old;
+	
+	old = config->xf86_crtc_notify;
+	config->xf86_crtc_notify = new;
+	return old;
+    }
+    return NULL;
+}
+
+void
+xf86_unwrap_crtc_notify(ScreenPtr screen, xf86_crtc_notify_proc_ptr old)
+{
+    if (xf86CrtcConfigPrivateIndex != -1)
+    {
+	ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+	xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    
+	config->xf86_crtc_notify = old;
+    }
+}
+
+void
+xf86_crtc_notify(ScreenPtr screen)
+{
+    ScrnInfoPtr		scrn = xf86Screens[screen->myNum];
+    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(scrn);
+    
+    if (config->xf86_crtc_notify)
+	config->xf86_crtc_notify(screen);
+}
+
+Bool
+xf86_crtc_supports_gamma(ScrnInfoPtr pScrn)
+{
+    if (xf86CrtcConfigPrivateIndex != -1) {
+	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+	xf86CrtcPtr crtc;
+
+	/* for multiple drivers loaded we need this */
+	if (!xf86_config)
+		return FALSE;
+	if (xf86_config->num_crtc == 0)
+	    return FALSE;
+	crtc = xf86_config->crtc[0];
+
+	return crtc->funcs->gamma_set != NULL;
+    }
+
+    return FALSE;
+}
diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.h b/xorg-server/hw/xfree86/modes/xf86Crtc.h
index 68a968cc2..ffb2efff4 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.h
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.h
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2006 Keith Packard
+ * Copyright © 2011 Aaron Plattner
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -223,7 +224,7 @@ typedef struct _xf86CrtcFuncs {
 
 } xf86CrtcFuncsRec, *xf86CrtcFuncsPtr;
 
-#define XF86_CRTC_VERSION 3
+#define XF86_CRTC_VERSION 4
 
 struct _xf86Crtc {
     /**
@@ -361,6 +362,19 @@ struct _xf86Crtc {
      * Clear the shadow
      */
     Bool	    shadowClear;
+
+    /**
+     * Indicates that the driver is handling the transform, so the shadow
+     * surface should be disabled.  The driver writes this field before calling
+     * xf86CrtcRotate to indicate that it is handling the transform (including
+     * rotation and reflection).
+     *
+     * Setting this flag also causes the server to stop adjusting the cursor
+     * image and position.
+     *
+     * Added in ABI version 4
+     */
+    Bool	    driverIsPerformingTransform;
 };
 
 typedef struct _xf86OutputFuncs {
@@ -934,6 +948,14 @@ xf86_hide_cursors (ScrnInfoPtr scrn);
 extern _X_EXPORT void
 xf86_cursors_fini (ScreenPtr screen);
 
+/**
+ * Transform the cursor's coordinates based on the crtc transform.  Normally
+ * this is done by the server, but if crtc->driverIsPerformingTransform is TRUE,
+ * then the server does not transform the cursor position automatically.
+ */
+extern _X_EXPORT void
+xf86CrtcTransformCursorPos (xf86CrtcPtr crtc, int *x, int *y);
+
 /*
  * For overlay video, compute the relevant CRTC and
  * clip video to that.
diff --git a/xorg-server/hw/xfree86/modes/xf86Cursors.c b/xorg-server/hw/xfree86/modes/xf86Cursors.c
index 23c48eb9e..4a03428ea 100644
--- a/xorg-server/hw/xfree86/modes/xf86Cursors.c
+++ b/xorg-server/hw/xfree86/modes/xf86Cursors.c
@@ -1,6 +1,6 @@
 /*
  * Copyright © 2007 Keith Packard
- * Copyright © 2010 Aaron Plattner
+ * Copyright © 2010-2011 Aaron Plattner
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -47,6 +47,18 @@
 #include "inputstr.h"
 
 /*
+ * Returns the rotation being performed by the server.  If the driver indicates
+ * that it's handling the screen transform, then this returns RR_Rotate_0.
+ */
+static Rotation
+xf86_crtc_cursor_rotation (xf86CrtcPtr crtc)
+{
+    if (crtc->driverIsPerformingTransform)
+	return RR_Rotate_0;
+    return crtc->rotation;
+}
+
+/*
  * Given a screen coordinate, rotate back to a cursor source coordinate
  */
 static void
@@ -214,6 +226,7 @@ xf86_crtc_convert_cursor_to_argb (xf86CrtcPtr crtc, unsigned char *src)
     int			xin, yin;
     int			flags = cursor_info->Flags;
     CARD32		bits;
+    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
 
 #ifdef ARGB_CURSOR
     crtc->cursor_argb = FALSE;
@@ -222,7 +235,7 @@ xf86_crtc_convert_cursor_to_argb (xf86CrtcPtr crtc, unsigned char *src)
     for (y = 0; y < cursor_info->MaxHeight; y++)
 	for (x = 0; x < cursor_info->MaxWidth; x++) 
 	{
-	    xf86_crtc_rotate_coord (crtc->rotation,
+	    xf86_crtc_rotate_coord (rotation,
 				    cursor_info->MaxWidth,
 				    cursor_info->MaxHeight,
 				    x, y, &xin, &yin);
@@ -324,7 +337,36 @@ xf86_show_cursors (ScrnInfoPtr scrn)
 	    xf86_crtc_show_cursor (crtc);
     }
 }
-    
+
+void xf86CrtcTransformCursorPos (xf86CrtcPtr crtc, int *x, int *y)
+{
+    ScrnInfoPtr scrn = crtc->scrn;
+    ScreenPtr screen = scrn->pScreen;
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+    xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
+    xf86CursorScreenPtr ScreenPriv =
+	(xf86CursorScreenPtr)dixLookupPrivate(&screen->devPrivates,
+					      xf86CursorScreenKey);
+    struct pict_f_vector v;
+    int dx, dy;
+
+    v.v[0] = (*x + ScreenPriv->HotX) + 0.5;
+    v.v[1] = (*y + ScreenPriv->HotY) + 0.5;
+    v.v[2] = 1;
+    pixman_f_transform_point (&crtc->f_framebuffer_to_crtc, &v);
+    /* cursor will have 0.5 added to it already so floor is sufficent */
+    *x = floor (v.v[0]);
+    *y = floor (v.v[1]);
+    /*
+     * Transform position of cursor upper left corner
+     */
+    xf86_crtc_rotate_coord_back (crtc->rotation, cursor_info->MaxWidth,
+				 cursor_info->MaxHeight, ScreenPriv->HotX,
+				 ScreenPriv->HotY, &dx, &dy);
+    *x -= dx;
+    *y -= dy;
+}
+
 static void
 xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
 {
@@ -333,36 +375,12 @@ xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
     xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
     DisplayModePtr	mode = &crtc->mode;
     Bool		in_range;
-    int			dx, dy;
 
     /*
      * Transform position of cursor on screen
      */
-    if (crtc->transform_in_use)
-    {
-	ScreenPtr	screen = scrn->pScreen;
-	xf86CursorScreenPtr ScreenPriv =
-	    (xf86CursorScreenPtr)dixLookupPrivate(&screen->devPrivates,
-						  xf86CursorScreenKey);
-	struct pict_f_vector   v;
-
-	v.v[0] = (x + ScreenPriv->HotX) + 0.5;
-	v.v[1] = (y + ScreenPriv->HotY) + 0.5;
-	v.v[2] = 1;
-	pixman_f_transform_point (&crtc->f_framebuffer_to_crtc, &v);
-	/* cursor will have 0.5 added to it already so floor is sufficent */
-	x = floor (v.v[0]);
-	y = floor (v.v[1]);
-	/*
-	 * Transform position of cursor upper left corner
-	 */
-	xf86_crtc_rotate_coord_back (crtc->rotation,
-				     cursor_info->MaxWidth,
-				     cursor_info->MaxHeight,
-				     ScreenPriv->HotX, ScreenPriv->HotY, &dx, &dy);
-	x -= dx;
-	y -= dy;
-   }
+    if (crtc->transform_in_use && !crtc->driverIsPerformingTransform)
+	xf86CrtcTransformCursorPos(crtc, &x, &y);
     else
     {
 	x -= crtc->x;
@@ -420,12 +438,13 @@ xf86_crtc_load_cursor_image (xf86CrtcPtr crtc, CARD8 *src)
     xf86CrtcConfigPtr   xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
     xf86CursorInfoPtr	cursor_info = xf86_config->cursor_info;
     CARD8		*cursor_image;
+    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
 
 #ifdef ARGB_CURSOR
     crtc->cursor_argb = FALSE;
 #endif
 
-    if (crtc->rotation == RR_Rotate_0)
+    if (rotation == RR_Rotate_0)
 	cursor_image = src;
     else
     {
@@ -439,7 +458,7 @@ xf86_crtc_load_cursor_image (xf86CrtcPtr crtc, CARD8 *src)
         for (y = 0; y < cursor_info->MaxHeight; y++)
 	    for (x = 0; x < cursor_info->MaxWidth; x++) 
 	    {
-		xf86_crtc_rotate_coord (crtc->rotation,
+		xf86_crtc_rotate_coord (rotation,
 					cursor_info->MaxWidth,
 					cursor_info->MaxHeight,
 					x, y, &xin, &yin);
@@ -532,12 +551,13 @@ xf86_crtc_load_cursor_argb (xf86CrtcPtr crtc, CursorPtr cursor)
     int			source_height = cursor->bits->height;
     int			image_width = cursor_info->MaxWidth;
     int			image_height = cursor_info->MaxHeight;
-    
+    const Rotation	rotation = xf86_crtc_cursor_rotation(crtc);
+
     for (y = 0; y < image_height; y++)
 	for (x = 0; x < image_width; x++)
 	{
-	    xf86_crtc_rotate_coord (crtc->rotation, image_width, image_height,
-				    x, y, &xin, &yin);
+	    xf86_crtc_rotate_coord (rotation, image_width, image_height, x, y,
+				    &xin, &yin);
 	    if (xin < source_width && yin < source_height)
 		bits = cursor_source[yin * source_width + xin];
 	    else
diff --git a/xorg-server/hw/xfree86/modes/xf86Rotate.c b/xorg-server/hw/xfree86/modes/xf86Rotate.c
index 57c3499ac..ff7000b5a 100644
--- a/xorg-server/hw/xfree86/modes/xf86Rotate.c
+++ b/xorg-server/hw/xfree86/modes/xf86Rotate.c
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2006 Keith Packard
+ * Copyright © 2011 Aaron Plattner
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -84,7 +85,10 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
     int			n = RegionNumRects(region);
     BoxPtr		b = RegionRects(region);
     XID			include_inferiors = IncludeInferiors;
-    
+
+    if (crtc->driverIsPerformingTransform)
+	return;
+
     src = CreatePicture (None,
 			 &root->drawable,
 			 format,
@@ -194,7 +198,7 @@ xf86RotatePrepare (ScreenPtr pScreen)
 	    if (!xf86_config->rotation_damage_registered)
 	    {
 		/* Hook damage to screen pixmap */
-		DamageRegister (&(*pScreen->GetScreenPixmap)(pScreen)->drawable,
+		DamageRegister (&pScreen->root->drawable,
 				xf86_config->rotation_damage);
 		xf86_config->rotation_damage_registered = TRUE;
 		EnableLimitedSchedulingLatency();
@@ -290,7 +294,7 @@ xf86RotateDestroy (xf86CrtcPtr crtc)
     }
 
     for (c = 0; c < xf86_config->num_crtc; c++)
-	if (xf86_config->crtc[c]->transform_in_use)
+	if (xf86_config->crtc[c]->rotatedData)
 	    return;
 
     /*
@@ -301,7 +305,7 @@ xf86RotateDestroy (xf86CrtcPtr crtc)
 	/* Free damage structure */
 	if (xf86_config->rotation_damage_registered)
 	{
-	    DamageUnregister (&(*pScreen->GetScreenPixmap)(pScreen)->drawable,
+	    DamageUnregister (&pScreen->root->drawable,
 			      xf86_config->rotation_damage);
 	    xf86_config->rotation_damage_registered = FALSE;
 	    DisableLimitedSchedulingLatency();
@@ -414,52 +418,73 @@ xf86CrtcRotate (xf86CrtcPtr crtc)
     }
     else
     {
-	/*
-	 * these are the size of the shadow pixmap, which
-	 * matches the mode, not the pre-rotated copy in the
-	 * frame buffer
-	 */
-	int	    width = crtc->mode.HDisplay;
-	int	    height = crtc->mode.VDisplay;
-	void	    *shadowData = crtc->rotatedData;
-	PixmapPtr   shadow = crtc->rotatedPixmap;
-	int	    old_width = shadow ? shadow->drawable.width : 0;
-	int	    old_height = shadow ? shadow->drawable.height : 0;
-
-	/* Allocate memory for rotation */
-	if (old_width != width || old_height != height)
-	{
-	    if (shadow || shadowData)
+	if (crtc->driverIsPerformingTransform) {
+	    xf86RotateDestroy(crtc);
+	} else {
+	    /*
+	     * these are the size of the shadow pixmap, which
+	     * matches the mode, not the pre-rotated copy in the
+	     * frame buffer
+	     */
+	    int		width = crtc->mode.HDisplay;
+	    int		height = crtc->mode.VDisplay;
+	    void	*shadowData = crtc->rotatedData;
+	    PixmapPtr	shadow = crtc->rotatedPixmap;
+	    int		old_width = shadow ? shadow->drawable.width : 0;
+	    int		old_height = shadow ? shadow->drawable.height : 0;
+
+	    /* Allocate memory for rotation */
+	    if (old_width != width || old_height != height)
 	    {
-		crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
-		crtc->rotatedPixmap = NULL;
-		crtc->rotatedData = NULL;
+		if (shadow || shadowData)
+		{
+		    crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
+		    crtc->rotatedPixmap = NULL;
+		    crtc->rotatedData = NULL;
+		}
+		shadowData = crtc->funcs->shadow_allocate (crtc, width, height);
+		if (!shadowData)
+		    goto bail1;
+		crtc->rotatedData = shadowData;
+		/* shadow will be damaged in xf86RotatePrepare */
+	    }
+	    else
+	    {
+		/* mark shadowed area as damaged so it will be repainted */
+		damage = TRUE;
 	    }
-	    shadowData = crtc->funcs->shadow_allocate (crtc, width, height);
-	    if (!shadowData)
-		goto bail1;
-	    crtc->rotatedData = shadowData;
-	    /* shadow will be damaged in xf86RotatePrepare */
-	}
-	else
-	{
-	    /* mark shadowed area as damaged so it will be repainted */
-	    damage = TRUE;
-	}
 
-	if (!xf86_config->rotation_damage)
-	{
-	    /* Create damage structure */
-	    xf86_config->rotation_damage = DamageCreate (NULL, NULL,
-						DamageReportNone,
-						TRUE, pScreen, pScreen);
 	    if (!xf86_config->rotation_damage)
-		goto bail2;
-	    
-	    /* Wrap block handler */
-	    if (!xf86_config->BlockHandler) {
-		xf86_config->BlockHandler = pScreen->BlockHandler;
-		pScreen->BlockHandler = xf86RotateBlockHandler;
+	    {
+		/* Create damage structure */
+		xf86_config->rotation_damage = DamageCreate (NULL, NULL,
+						    DamageReportNone,
+						    TRUE, pScreen, pScreen);
+		if (!xf86_config->rotation_damage)
+		    goto bail2;
+
+		/* Wrap block handler */
+		if (!xf86_config->BlockHandler) {
+		    xf86_config->BlockHandler = pScreen->BlockHandler;
+		    pScreen->BlockHandler = xf86RotateBlockHandler;
+		}
+	    }
+
+	    if (0)
+	    {
+	bail2:
+		if (shadow || shadowData)
+		{
+		    crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
+		    crtc->rotatedPixmap = NULL;
+		    crtc->rotatedData = NULL;
+		}
+	bail1:
+		if (old_width && old_height)
+		    crtc->rotatedPixmap =
+			crtc->funcs->shadow_create (crtc, NULL, old_width,
+						    old_height);
+		return FALSE;
 	    }
 	}
 #ifdef RANDR_12_INTERFACE
@@ -482,24 +507,6 @@ xf86CrtcRotate (xf86CrtcPtr crtc)
 	    }
 	}
 #endif
-
-	if (0)
-	{
-    bail2:
-	    if (shadow || shadowData)
-	    {
-		crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
-		crtc->rotatedPixmap = NULL;
-		crtc->rotatedData = NULL;
-	    }
-    bail1:
-	    if (old_width && old_height)
-		crtc->rotatedPixmap = crtc->funcs->shadow_create (crtc,
-								  NULL,
-								  old_width,
-								  old_height);
-	    return FALSE;
-	}
 	crtc->transform_in_use = TRUE;
     }
     crtc->crtc_to_framebuffer = crtc_to_fb;
diff --git a/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c b/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
index 7b5d2c7a4..15eb2a422 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/alpha_video.c
@@ -1,719 +1,719 @@
-/*

- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

- * Copyright 1993 by David Wexelblat <dwex@goblin.org>

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the names of Rich Murphey and David Wexelblat 

- * not be used in advertising or publicity pertaining to distribution of 

- * the software without specific, written prior permission.  Rich Murphey and

- * David Wexelblat make no representations about the suitability of this 

- * software for any purpose.  It is provided "as is" without express or 

- * implied warranty.

- *

- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 

- * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 

- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 

- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- *

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <X11/X.h>

-#include "xf86.h"

-#include "xf86Priv.h"

-

-#include <sys/param.h>

-#ifndef __NetBSD__

-#  include <sys/sysctl.h>

-#  if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

-#      include <machine/sysarch.h>

-#   endif

-# else

-#  include <machine/sysarch.h>

-#endif

-

-#include "xf86Axp.h"

-

-#include "xf86_OSlib.h"

-#include "xf86OSpriv.h"

-

-#if defined(__NetBSD__) && !defined(MAP_FILE)

-#define MAP_FLAGS MAP_SHARED

-#else

-#define MAP_FLAGS (MAP_FILE | MAP_SHARED)

-#endif

-

-#ifndef MAP_FAILED

-#define MAP_FAILED ((caddr_t)-1)

-#endif

-

-axpDevice bsdGetAXP(void);

-

-#ifndef __NetBSD__

-extern unsigned long dense_base(void);

-

-static int axpSystem = -1;

-static unsigned long hae_thresh;

-static unsigned long hae_mask;

-static unsigned long bus_base;

-static unsigned long sparse_size;

-

-static unsigned long

-memory_base(void)

-{

-    static unsigned long base = 0;

-

-    if (base == 0) {

-	size_t len = sizeof(base);

-	int error;

-#ifdef __OpenBSD__

-       int mib[3];

-

-       mib[0] = CTL_MACHDEP;

-       mib[1] = CPU_CHIPSET;

-       mib[2] = CPU_CHIPSET_MEM;

-

-       if ((error = sysctl(mib, 3, &base, &len, NULL, 0)) < 0)

-#else

-	if ((error = sysctlbyname("hw.chipset.memory", &base, &len,

-				  0, 0)) < 0)

-#endif

-	    FatalError("xf86MapVidMem: can't find memory\n");

-    }

-

-    return base;

-}

-

-static int

-has_bwx(void)

-{

-    static int bwx = 0;

-    size_t len = sizeof(bwx);

-    int error;

-#ifdef __OpenBSD__

-    int mib[3];

-

-    mib[0] = CTL_MACHDEP;

-    mib[1] = CPU_CHIPSET;

-    mib[2] = CPU_CHIPSET_BWX;

-

-    if ((error = sysctl(mib, 3, &bwx, &len, NULL, 0)) < 0)

-	return FALSE;

-    else

-	return bwx;

-#else

-    if ((error = sysctlbyname("hw.chipset.bwx", &bwx, &len, 0, 0)) < 0)

-	return FALSE;

-    else

-	return bwx;

-#endif

-}

-#else /* __NetBSD__ */

-static unsigned long hae_thresh = (1UL << 24);

-static unsigned long hae_mask = 0xf8000000UL; /* XXX - should use xf86AXP.c */

-static struct alpha_bus_window *abw;

-static int abw_count = -1;

-

-static void

-init_abw(void)

-{

-	if (abw_count < 0) {

-		abw_count = alpha_bus_getwindows(ALPHA_BUS_TYPE_PCI_MEM, &abw);

-		if (abw_count <= 0)

-			FatalError("init_abw: alpha_bus_getwindows failed\n");

-	}

-}

-

-static int

-has_bwx(void)

-{

-	if (abw_count < 0)

-		init_abw();

-

-	xf86Msg(X_INFO, "has_bwx = %d\n", 

-		abw[0].abw_abst.abst_flags & ABST_BWX ? 1 : 0);	/* XXXX */

-	return abw[0].abw_abst.abst_flags & ABST_BWX;

-}

-

-static unsigned long

-dense_base(void)

-{

-	if (abw_count < 0)

-		init_abw();

-

-	/* XXX check abst_flags for ABST_DENSE just to be safe? */

-	xf86Msg(X_INFO, "dense base = %#lx\n", 

-		abw[0].abw_abst.abst_sys_start); /* XXXX */

-	return abw[0].abw_abst.abst_sys_start;

-}

-

-static unsigned long

-memory_base(void)

-{

-	if (abw_count < 0)

-		init_abw();

-	

-	if (abw_count > 1) {

-		xf86Msg(X_INFO, "memory base = %#lx\n", 

-			abw[1].abw_abst.abst_sys_start); /* XXXX */

-		return abw[1].abw_abst.abst_sys_start;

-	} else if (abw_count == 1) {

-		/* assume memory_base == dense_base */

-		xf86Msg(X_INFO, "memory base = %#lx\n",

-			abw[0].abw_abst.abst_sys_start); /* XXXX */

-		return abw[0].abw_abst.abst_sys_start;

-	} else {

-		xf86Msg(X_INFO, "no memory base\n"); /* XXXX */

-		return 0;

-	}

-}

-#endif /* __NetBSD__ */

-

-#define BUS_BASE	dense_base()

-#define BUS_BASE_BWX	memory_base()

-

-/***************************************************************************/

-/* Video Memory Mapping section                                            */

-/***************************************************************************/

-

-#ifdef __OpenBSD__

-#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\

-                  "\tin /etc/sysctl.conf and reboot your machine\n" \

-                  "\trefer to xf86(4) for details"

-#endif

-

-static Bool useDevMem = FALSE;

-static int  devMemFd = -1;

-

-#ifdef HAS_APERTURE_DRV

-#define DEV_APERTURE "/dev/xf86"

-#endif

-#define DEV_MEM "/dev/mem"

-

-static pointer mapVidMem(int, unsigned long, unsigned long, int);

-static void unmapVidMem(int, pointer, unsigned long);

-static pointer mapVidMemSparse(int, unsigned long, unsigned long, int);

-static void unmapVidMemSparse(int, pointer, unsigned long);

-

-/*

- * Check if /dev/mem can be mmap'd.  If it can't print a warning when

- * "warn" is TRUE.

- */

-static void

-checkDevMem(Bool warn)

-{

-	static Bool devMemChecked = FALSE;

-	int fd;

-	pointer base;

-

-	if (devMemChecked)

-	    return;

-	devMemChecked = TRUE;

-

-#ifdef HAS_APERTURE_DRV

-       /* Try the aperture driver first */

-       if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0) {

-           /* Try to map a page at the VGA address */

-           base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

-                            MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

-       

-           if (base != MAP_FAILED) {

-               munmap((caddr_t)base, 4096);

-               devMemFd = fd;

-               useDevMem = TRUE;

-               xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",

-                       DEV_APERTURE);

-               return;

-           } else {

-               if (warn) {

-                   xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

-                           DEV_APERTURE, strerror(errno));

-               }

-           }

-       } 

-#endif

-       if ((fd = open(DEV_MEM, O_RDWR)) >= 0) {

-	    /* Try to map a page at the VGA address */

-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

-				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

-	

-	    if (base != MAP_FAILED) {

-		munmap((caddr_t)base, 4096);

-		devMemFd = fd;

-		useDevMem = TRUE;

-		return;

-	    } else {

-		if (warn) {

-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

-			    DEV_MEM, strerror(errno));

-		}

-	    }

-	}

-	if (warn) { 

-#ifndef HAS_APERTURE_DRV

-           xf86Msg(X_WARNING, "checkDevMem: failed to open/mmap %s (%s)\n",

-                   DEV_MEM, strerror(errno));

-#else

-#ifndef __OpenBSD__

-           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

-               "\t(%s)\n", DEV_APERTURE, DEV_MEM, strerror(errno));

-#else /* __OpenBSD__ */

-           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

-                   "\t(%s)\n%s", DEV_APERTURE, DEV_MEM, strerror(errno),

-                   SYSCTL_MSG);

-#endif /* __OpenBSD__ */

-#endif

-           xf86ErrorF("\tlinear framebuffer access unavailable\n");

-	}

-	useDevMem = FALSE;

-	return;

-}

-

-void

-xf86OSInitVidMem(VidMemInfoPtr pVidMem)

-{

-	checkDevMem(TRUE);

-	pVidMem->linearSupported = useDevMem;

-

-	if (has_bwx()) {

-	    xf86Msg(X_PROBED,"Machine type has 8/16 bit access\n");

-	    pVidMem->mapMem = mapVidMem;

-	    pVidMem->unmapMem = unmapVidMem;

-	} else {

-	    xf86Msg(X_PROBED,"Machine needs sparse mapping\n");

-	    pVidMem->mapMem = mapVidMemSparse;

-	    pVidMem->unmapMem = unmapVidMemSparse;

-#ifndef __NetBSD__

-	    if (axpSystem == -1)

-                axpSystem = bsdGetAXP(); 

-	    hae_thresh = xf86AXPParams[axpSystem].hae_thresh;

-            hae_mask = xf86AXPParams[axpSystem].hae_mask;

-            sparse_size = xf86AXPParams[axpSystem].size;

-#endif /* __NetBSD__ */

-	}

-	pVidMem->initialised = TRUE;

-}

-

-static pointer

-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

-{

-	pointer base;

-

-	checkDevMem(FALSE);

-	Base = Base & ((1L<<32) - 1);

-

-	if (useDevMem)

-	{

-	    if (devMemFd < 0) 

-	    {

-		FatalError("xf86MapVidMem: failed to open %s (%s)\n",

-			   DEV_MEM, strerror(errno));

-	    }

-	    base = mmap((caddr_t)0, Size,

-			(flags & VIDMEM_READONLY) ?

-			 PROT_READ : (PROT_READ | PROT_WRITE),

-			 MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);

-	    if (base == MAP_FAILED)

-	    {

-		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)\n",

-			   "xf86MapVidMem", DEV_MEM, Size, Base, 

-			   strerror(errno));

-	    }

-	    return base;

-	}

-		

-	/* else, mmap /dev/vga */

-	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)

-	{

-		FatalError("%s: Address 0x%lx outside allowable range\n",

-			   "xf86MapVidMem", Base);

-	}

-	base = mmap(0, Size,

-		    (flags & VIDMEM_READONLY) ?

-		     PROT_READ : (PROT_READ | PROT_WRITE),

-		    MAP_FLAGS, xf86Info.screenFd,

-		    (unsigned long)Base + BUS_BASE);

-	if (base == MAP_FAILED)

-	{

-	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",

-		       strerror(errno));

-	}

-	return base;

-}

-

-static void

-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

-{

-	munmap((caddr_t)Base, Size);

-}

-

-/*

- * Read BIOS via mmap()ing DEV_MEM

- */

-

-int

-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

-	     int Len)

-{

-	unsigned char *ptr;

-	int psize;

-	int mlen;

-

-	checkDevMem(TRUE);

-	if (devMemFd == -1) {

-	    return -1;

-	}

-

-	psize = getpagesize();

-	Offset += Base & (psize - 1);

-	Base &= ~(psize - 1);

-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

-					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);

-	if ((long)ptr == -1)

-	{

-		xf86Msg(X_WARNING, 

-			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",

-			DEV_MEM, Len, Base, Offset, strerror(errno));

-		return -1;

-	}

-#ifdef DEBUG

-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

-		Base, ptr[0] | (ptr[1] << 8));

-#endif

-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

-	(void)munmap((caddr_t)ptr, mlen);

-#ifdef DEBUG

-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"

-		"-> %02x %02x %02x %02x...\n",

-		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

-#endif

-	return Len;

-}

-

-

-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)

-

-extern int ioperm(unsigned long from, unsigned long num, int on);

-

-Bool

-xf86EnableIO()

-{

-    if (!ioperm(0, 65536, TRUE))

-	return TRUE;

-    return FALSE;

-}

-

-void

-xf86DisableIO()

-{

-	return;

-}

-

-#endif /* __FreeBSD_kernel__ || __OpenBSD__ */

-

-#ifdef USE_ALPHA_PIO

-

-Bool

-xf86EnableIO()

-{

-	alpha_pci_io_enable(1);

-	return TRUE;

-}

-

-void

-xf86DisableIO()

-{

-	alpha_pci_io_enable(0);

-}

-

-#endif /* USE_ALPHA_PIO */

-

-#define vuip    volatile unsigned int *

-

-static unsigned long msb_set = 0;

-static pointer memSBase = 0;

-static pointer memBase = 0;

-

-extern int readDense8(pointer Base, register unsigned long Offset);

-extern int readDense16(pointer Base, register unsigned long Offset);

-extern int readDense32(pointer Base, register unsigned long Offset);

-extern void

-writeDenseNB8(int Value, pointer Base, register unsigned long Offset);

-extern void

-writeDenseNB16(int Value, pointer Base, register unsigned long Offset);

-extern void

-writeDenseNB32(int Value, pointer Base, register unsigned long Offset);

-extern void

-writeDense8(int Value, pointer Base, register unsigned long Offset);

-extern void

-writeDense16(int Value, pointer Base, register unsigned long Offset);

-extern void

-writeDense32(int Value, pointer Base, register unsigned long Offset);

-

-static int readSparse8(pointer Base, register unsigned long Offset);

-static int readSparse16(pointer Base, register unsigned long Offset);

-static int readSparse32(pointer Base, register unsigned long Offset);

-static void

-writeSparseNB8(int Value, pointer Base, register unsigned long Offset);

-static void

-writeSparseNB16(int Value, pointer Base, register unsigned long Offset);

-static void

-writeSparseNB32(int Value, pointer Base, register unsigned long Offset);

-static void

-writeSparse8(int Value, pointer Base, register unsigned long Offset);

-static void

-writeSparse16(int Value, pointer Base, register unsigned long Offset);

-static void

-writeSparse32(int Value, pointer Base, register unsigned long Offset);

-

-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

-extern int sysarch(int, void *);

-#endif

-

-struct parms {

-	u_int64_t hae;

-};

-

-#ifndef __NetBSD__

-static int

-sethae(u_int64_t hae)

-{

-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

-#ifndef ALPHA_SETHAE

-#define ALPHA_SETHAE 0

-#endif

-	struct parms p;

-	p.hae = hae;

-	return (sysarch(ALPHA_SETHAE, (char *)&p));

-#endif

-#ifdef __OpenBSD__

-	return -1;

-#endif

-}

-#endif /* __NetBSD__ */

-

-static pointer

-mapVidMemSparse(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

-{

-    static Bool was_here = FALSE;

-

-    if (!was_here) {

-      was_here = TRUE;

-

-      checkDevMem(FALSE);

-

-      xf86WriteMmio8 = writeSparse8;

-      xf86WriteMmio16 = writeSparse16;

-      xf86WriteMmio32 = writeSparse32;

-      xf86WriteMmioNB8 = writeSparseNB8;

-      xf86WriteMmioNB16 = writeSparseNB16;

-      xf86WriteMmioNB32 = writeSparseNB32;

-      xf86ReadMmio8 = readSparse8;

-      xf86ReadMmio16 = readSparse16;

-      xf86ReadMmio32 = readSparse32;

-	

-      memBase = mmap((caddr_t)0, 0x100000000,

-		     PROT_READ | PROT_WRITE,

-		     MAP_SHARED, devMemFd,

-		     (off_t) BUS_BASE);

-      memSBase = mmap((caddr_t)0, 0x100000000,

-		      PROT_READ | PROT_WRITE,

-		      MAP_SHARED, devMemFd,

-		      (off_t) BUS_BASE_BWX);

-      

-      if (memSBase == MAP_FAILED || memBase == MAP_FAILED)	{

-	FatalError("xf86MapVidMem: Could not mmap framebuffer (%s)\n",

-		   strerror(errno));

-      }

-    }

-    return (pointer)((unsigned long)memBase + Base);

-}

-

-static void

-unmapVidMemSparse(int ScreenNum, pointer Base, unsigned long Size)

-{

-}

-

-static int

-readSparse8(pointer Base, register unsigned long Offset)

-{

-    register unsigned long result, shift;

-    register unsigned long msb;

-    mem_barrier();

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    shift = (Offset & 0x3) << 3;

-      if (Offset >= (hae_thresh)) {

-        msb = Offset & hae_mask;

-        Offset -= msb;

-	if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-	}

-      }

-    result = *(vuip) ((unsigned long)memSBase + (Offset << 5));

-    result >>= shift;

-    return 0xffUL & result;

-}

-

-static int

-readSparse16(pointer Base, register unsigned long Offset)

-{

-    register unsigned long result, shift;

-    register unsigned long msb;

-

-    mem_barrier();

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    shift = (Offset & 0x2) << 3;

-    if (Offset >= (hae_thresh)) {

-        msb = Offset & hae_mask;

-        Offset -= msb;

-      if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-      }

-    }

-    result = *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2)));

-    result >>= shift;

-    return 0xffffUL & result;

-}

-

-static int

-readSparse32(pointer Base, register unsigned long Offset)

-{

-    mem_barrier();

-    return *(vuip)((unsigned long)Base+(Offset));

-}

-

-static void

-writeSparse8(int Value, pointer Base, register unsigned long Offset)

-{

-    register unsigned long msb;

-    register unsigned int b = Value & 0xffU;

-

-    write_mem_barrier();

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    if (Offset >= (hae_thresh)) {

-      msb = Offset & hae_mask;

-      Offset -= msb;

-      if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-      }

-    }

-    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;

-}

-

-static void

-writeSparse16(int Value, pointer Base, register unsigned long Offset)

-{

-    register unsigned long msb;

-    register unsigned int w = Value & 0xffffU;

-

-    write_mem_barrier();

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    if (Offset >= (hae_thresh)) {

-      msb = Offset & hae_mask;

-      Offset -= msb;

-      if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-      }

-    }

-    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =

-      w * 0x00010001;

-

-}

-

-static void

-writeSparse32(int Value, pointer Base, register unsigned long Offset)

-{

-    write_mem_barrier();

-    *(vuip)((unsigned long)Base + (Offset)) = Value;

-    return;

-}

-

-static void

-writeSparseNB8(int Value, pointer Base, register unsigned long Offset)

-{

-    register unsigned long msb;

-    register unsigned int b = Value & 0xffU;

-

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    if (Offset >= (hae_thresh)) {

-      msb = Offset & hae_mask;

-      Offset -= msb;

-      if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-      }

-    }

-    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;

-}

-

-static void

-writeSparseNB16(int Value, pointer Base, register unsigned long Offset)

-{

-    register unsigned long msb;

-    register unsigned int w = Value & 0xffffU;

-

-    Offset += (unsigned long)Base - (unsigned long)memBase;

-    if (Offset >= (hae_thresh)) {

-      msb = Offset & hae_mask ;

-      Offset -= msb;

-      if (msb_set != msb) {

-#ifndef __NetBSD__

-	sethae(msb);

-#endif

-	msb_set = msb;

-      }

-    }

-    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =

-      w * 0x00010001;

-}

-

-static void

-writeSparseNB32(int Value, pointer Base, register unsigned long Offset)

-{

-    *(vuip)((unsigned long)Base + (Offset)) = Value;

-    return;

-}

-

-void (*xf86WriteMmio8)(int Value, pointer Base, unsigned long Offset)

-     = writeDense8;

-void (*xf86WriteMmio16)(int Value, pointer Base, unsigned long Offset)

-     = writeDense16;

-void (*xf86WriteMmio32)(int Value, pointer Base, unsigned long Offset)

-     = writeDense32;

-void (*xf86WriteMmioNB8)(int Value, pointer Base, unsigned long Offset)

-     = writeDenseNB8;

-void (*xf86WriteMmioNB16)(int Value, pointer Base, unsigned long Offset)

-     = writeDenseNB16;

-void (*xf86WriteMmioNB32)(int Value, pointer Base, unsigned long Offset)

-     = writeDenseNB32;

-int  (*xf86ReadMmio8)(pointer Base, unsigned long Offset)

-     = readDense8;

-int  (*xf86ReadMmio16)(pointer Base, unsigned long Offset)

-     = readDense16;

-int  (*xf86ReadMmio32)(pointer Base, unsigned long Offset)

-     = readDense32;

-

+/*
+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Rich Murphey and David Wexelblat 
+ * not be used in advertising or publicity pertaining to distribution of 
+ * the software without specific, written prior permission.  Rich Murphey and
+ * David Wexelblat make no representations about the suitability of this 
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ *
+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "xf86.h"
+#include "xf86Priv.h"
+
+#include <sys/param.h>
+#ifndef __NetBSD__
+#  include <sys/sysctl.h>
+#  if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#      include <machine/sysarch.h>
+#   endif
+# else
+#  include <machine/sysarch.h>
+#endif
+
+#include "xf86Axp.h"
+
+#include "xf86_OSlib.h"
+#include "xf86OSpriv.h"
+
+#if defined(__NetBSD__) && !defined(MAP_FILE)
+#define MAP_FLAGS MAP_SHARED
+#else
+#define MAP_FLAGS (MAP_FILE | MAP_SHARED)
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((caddr_t)-1)
+#endif
+
+axpDevice bsdGetAXP(void);
+
+#ifndef __NetBSD__
+extern unsigned long dense_base(void);
+
+static int axpSystem = -1;
+static unsigned long hae_thresh;
+static unsigned long hae_mask;
+static unsigned long bus_base;
+static unsigned long sparse_size;
+
+static unsigned long
+memory_base(void)
+{
+    static unsigned long base = 0;
+
+    if (base == 0) {
+	size_t len = sizeof(base);
+	int error;
+#ifdef __OpenBSD__
+       int mib[3];
+
+       mib[0] = CTL_MACHDEP;
+       mib[1] = CPU_CHIPSET;
+       mib[2] = CPU_CHIPSET_MEM;
+
+       if ((error = sysctl(mib, 3, &base, &len, NULL, 0)) < 0)
+#else
+	if ((error = sysctlbyname("hw.chipset.memory", &base, &len,
+				  0, 0)) < 0)
+#endif
+	    FatalError("xf86MapVidMem: can't find memory\n");
+    }
+
+    return base;
+}
+
+static int
+has_bwx(void)
+{
+    static int bwx = 0;
+    size_t len = sizeof(bwx);
+    int error;
+#ifdef __OpenBSD__
+    int mib[3];
+
+    mib[0] = CTL_MACHDEP;
+    mib[1] = CPU_CHIPSET;
+    mib[2] = CPU_CHIPSET_BWX;
+
+    if ((error = sysctl(mib, 3, &bwx, &len, NULL, 0)) < 0)
+	return FALSE;
+    else
+	return bwx;
+#else
+    if ((error = sysctlbyname("hw.chipset.bwx", &bwx, &len, 0, 0)) < 0)
+	return FALSE;
+    else
+	return bwx;
+#endif
+}
+#else /* __NetBSD__ */
+static unsigned long hae_thresh = (1UL << 24);
+static unsigned long hae_mask = 0xf8000000UL; /* XXX - should use xf86AXP.c */
+static struct alpha_bus_window *abw;
+static int abw_count = -1;
+
+static void
+init_abw(void)
+{
+	if (abw_count < 0) {
+		abw_count = alpha_bus_getwindows(ALPHA_BUS_TYPE_PCI_MEM, &abw);
+		if (abw_count <= 0)
+			FatalError("init_abw: alpha_bus_getwindows failed\n");
+	}
+}
+
+static int
+has_bwx(void)
+{
+	if (abw_count < 0)
+		init_abw();
+
+	xf86Msg(X_INFO, "has_bwx = %d\n", 
+		abw[0].abw_abst.abst_flags & ABST_BWX ? 1 : 0);	/* XXXX */
+	return abw[0].abw_abst.abst_flags & ABST_BWX;
+}
+
+static unsigned long
+dense_base(void)
+{
+	if (abw_count < 0)
+		init_abw();
+
+	/* XXX check abst_flags for ABST_DENSE just to be safe? */
+	xf86Msg(X_INFO, "dense base = %#lx\n", 
+		abw[0].abw_abst.abst_sys_start); /* XXXX */
+	return abw[0].abw_abst.abst_sys_start;
+}
+
+static unsigned long
+memory_base(void)
+{
+	if (abw_count < 0)
+		init_abw();
+	
+	if (abw_count > 1) {
+		xf86Msg(X_INFO, "memory base = %#lx\n", 
+			abw[1].abw_abst.abst_sys_start); /* XXXX */
+		return abw[1].abw_abst.abst_sys_start;
+	} else if (abw_count == 1) {
+		/* assume memory_base == dense_base */
+		xf86Msg(X_INFO, "memory base = %#lx\n",
+			abw[0].abw_abst.abst_sys_start); /* XXXX */
+		return abw[0].abw_abst.abst_sys_start;
+	} else {
+		xf86Msg(X_INFO, "no memory base\n"); /* XXXX */
+		return 0;
+	}
+}
+#endif /* __NetBSD__ */
+
+#define BUS_BASE	dense_base()
+#define BUS_BASE_BWX	memory_base()
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+#ifdef __OpenBSD__
+#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\
+                  "\tin /etc/sysctl.conf and reboot your machine\n" \
+                  "\trefer to xf86(4) for details"
+#endif
+
+static Bool useDevMem = FALSE;
+static int  devMemFd = -1;
+
+#ifdef HAS_APERTURE_DRV
+#define DEV_APERTURE "/dev/xf86"
+#endif
+#define DEV_MEM "/dev/mem"
+
+static pointer mapVidMem(int, unsigned long, unsigned long, int);
+static void unmapVidMem(int, pointer, unsigned long);
+static pointer mapVidMemSparse(int, unsigned long, unsigned long, int);
+static void unmapVidMemSparse(int, pointer, unsigned long);
+
+/*
+ * Check if /dev/mem can be mmap'd.  If it can't print a warning when
+ * "warn" is TRUE.
+ */
+static void
+checkDevMem(Bool warn)
+{
+	static Bool devMemChecked = FALSE;
+	int fd;
+	pointer base;
+
+	if (devMemChecked)
+	    return;
+	devMemChecked = TRUE;
+
+#ifdef HAS_APERTURE_DRV
+       /* Try the aperture driver first */
+       if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0) {
+           /* Try to map a page at the VGA address */
+           base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
+                            MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
+       
+           if (base != MAP_FAILED) {
+               munmap((caddr_t)base, 4096);
+               devMemFd = fd;
+               useDevMem = TRUE;
+               xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",
+                       DEV_APERTURE);
+               return;
+           } else {
+               if (warn) {
+                   xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
+                           DEV_APERTURE, strerror(errno));
+               }
+           }
+       } 
+#endif
+       if ((fd = open(DEV_MEM, O_RDWR)) >= 0) {
+	    /* Try to map a page at the VGA address */
+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
+				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
+	
+	    if (base != MAP_FAILED) {
+		munmap((caddr_t)base, 4096);
+		devMemFd = fd;
+		useDevMem = TRUE;
+		return;
+	    } else {
+		if (warn) {
+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
+			    DEV_MEM, strerror(errno));
+		}
+	    }
+	}
+	if (warn) { 
+#ifndef HAS_APERTURE_DRV
+           xf86Msg(X_WARNING, "checkDevMem: failed to open/mmap %s (%s)\n",
+                   DEV_MEM, strerror(errno));
+#else
+#ifndef __OpenBSD__
+           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
+               "\t(%s)\n", DEV_APERTURE, DEV_MEM, strerror(errno));
+#else /* __OpenBSD__ */
+           xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
+                   "\t(%s)\n%s", DEV_APERTURE, DEV_MEM, strerror(errno),
+                   SYSCTL_MSG);
+#endif /* __OpenBSD__ */
+#endif
+           xf86ErrorF("\tlinear framebuffer access unavailable\n");
+	}
+	useDevMem = FALSE;
+	return;
+}
+
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+	checkDevMem(TRUE);
+	pVidMem->linearSupported = useDevMem;
+
+	if (has_bwx()) {
+	    xf86Msg(X_PROBED,"Machine type has 8/16 bit access\n");
+	    pVidMem->mapMem = mapVidMem;
+	    pVidMem->unmapMem = unmapVidMem;
+	} else {
+	    xf86Msg(X_PROBED,"Machine needs sparse mapping\n");
+	    pVidMem->mapMem = mapVidMemSparse;
+	    pVidMem->unmapMem = unmapVidMemSparse;
+#ifndef __NetBSD__
+	    if (axpSystem == -1)
+                axpSystem = bsdGetAXP(); 
+	    hae_thresh = xf86AXPParams[axpSystem].hae_thresh;
+            hae_mask = xf86AXPParams[axpSystem].hae_mask;
+            sparse_size = xf86AXPParams[axpSystem].size;
+#endif /* __NetBSD__ */
+	}
+	pVidMem->initialised = TRUE;
+}
+
+static pointer
+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+	pointer base;
+
+	checkDevMem(FALSE);
+	Base = Base & ((1L<<32) - 1);
+
+	if (useDevMem)
+	{
+	    if (devMemFd < 0) 
+	    {
+		FatalError("xf86MapVidMem: failed to open %s (%s)\n",
+			   DEV_MEM, strerror(errno));
+	    }
+	    base = mmap((caddr_t)0, Size,
+			(flags & VIDMEM_READONLY) ?
+			 PROT_READ : (PROT_READ | PROT_WRITE),
+			 MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);
+	    if (base == MAP_FAILED)
+	    {
+		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)\n",
+			   "xf86MapVidMem", DEV_MEM, Size, Base, 
+			   strerror(errno));
+	    }
+	    return base;
+	}
+		
+	/* else, mmap /dev/vga */
+	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)
+	{
+		FatalError("%s: Address 0x%lx outside allowable range\n",
+			   "xf86MapVidMem", Base);
+	}
+	base = mmap(0, Size,
+		    (flags & VIDMEM_READONLY) ?
+		     PROT_READ : (PROT_READ | PROT_WRITE),
+		    MAP_FLAGS, xf86Info.consoleFd,
+		    (unsigned long)Base + BUS_BASE);
+	if (base == MAP_FAILED)
+	{
+	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",
+		       strerror(errno));
+	}
+	return base;
+}
+
+static void
+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+	munmap((caddr_t)Base, Size);
+}
+
+/*
+ * Read BIOS via mmap()ing DEV_MEM
+ */
+
+int
+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
+	     int Len)
+{
+	unsigned char *ptr;
+	int psize;
+	int mlen;
+
+	checkDevMem(TRUE);
+	if (devMemFd == -1) {
+	    return -1;
+	}
+
+	psize = getpagesize();
+	Offset += Base & (psize - 1);
+	Base &= ~(psize - 1);
+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
+					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);
+	if ((long)ptr == -1)
+	{
+		xf86Msg(X_WARNING, 
+			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",
+			DEV_MEM, Len, Base, Offset, strerror(errno));
+		return -1;
+	}
+#ifdef DEBUG
+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
+		Base, ptr[0] | (ptr[1] << 8));
+#endif
+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
+	(void)munmap((caddr_t)ptr, mlen);
+#ifdef DEBUG
+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"
+		"-> %02x %02x %02x %02x...\n",
+		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);
+#endif
+	return Len;
+}
+
+
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
+
+extern int ioperm(unsigned long from, unsigned long num, int on);
+
+Bool
+xf86EnableIO()
+{
+    if (!ioperm(0, 65536, TRUE))
+	return TRUE;
+    return FALSE;
+}
+
+void
+xf86DisableIO()
+{
+	return;
+}
+
+#endif /* __FreeBSD_kernel__ || __OpenBSD__ */
+
+#ifdef USE_ALPHA_PIO
+
+Bool
+xf86EnableIO()
+{
+	alpha_pci_io_enable(1);
+	return TRUE;
+}
+
+void
+xf86DisableIO()
+{
+	alpha_pci_io_enable(0);
+}
+
+#endif /* USE_ALPHA_PIO */
+
+#define vuip    volatile unsigned int *
+
+static unsigned long msb_set = 0;
+static pointer memSBase = 0;
+static pointer memBase = 0;
+
+extern int readDense8(pointer Base, register unsigned long Offset);
+extern int readDense16(pointer Base, register unsigned long Offset);
+extern int readDense32(pointer Base, register unsigned long Offset);
+extern void
+writeDenseNB8(int Value, pointer Base, register unsigned long Offset);
+extern void
+writeDenseNB16(int Value, pointer Base, register unsigned long Offset);
+extern void
+writeDenseNB32(int Value, pointer Base, register unsigned long Offset);
+extern void
+writeDense8(int Value, pointer Base, register unsigned long Offset);
+extern void
+writeDense16(int Value, pointer Base, register unsigned long Offset);
+extern void
+writeDense32(int Value, pointer Base, register unsigned long Offset);
+
+static int readSparse8(pointer Base, register unsigned long Offset);
+static int readSparse16(pointer Base, register unsigned long Offset);
+static int readSparse32(pointer Base, register unsigned long Offset);
+static void
+writeSparseNB8(int Value, pointer Base, register unsigned long Offset);
+static void
+writeSparseNB16(int Value, pointer Base, register unsigned long Offset);
+static void
+writeSparseNB32(int Value, pointer Base, register unsigned long Offset);
+static void
+writeSparse8(int Value, pointer Base, register unsigned long Offset);
+static void
+writeSparse16(int Value, pointer Base, register unsigned long Offset);
+static void
+writeSparse32(int Value, pointer Base, register unsigned long Offset);
+
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+extern int sysarch(int, void *);
+#endif
+
+struct parms {
+	u_int64_t hae;
+};
+
+#ifndef __NetBSD__
+static int
+sethae(u_int64_t hae)
+{
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#ifndef ALPHA_SETHAE
+#define ALPHA_SETHAE 0
+#endif
+	struct parms p;
+	p.hae = hae;
+	return (sysarch(ALPHA_SETHAE, (char *)&p));
+#endif
+#ifdef __OpenBSD__
+	return -1;
+#endif
+}
+#endif /* __NetBSD__ */
+
+static pointer
+mapVidMemSparse(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+    static Bool was_here = FALSE;
+
+    if (!was_here) {
+      was_here = TRUE;
+
+      checkDevMem(FALSE);
+
+      xf86WriteMmio8 = writeSparse8;
+      xf86WriteMmio16 = writeSparse16;
+      xf86WriteMmio32 = writeSparse32;
+      xf86WriteMmioNB8 = writeSparseNB8;
+      xf86WriteMmioNB16 = writeSparseNB16;
+      xf86WriteMmioNB32 = writeSparseNB32;
+      xf86ReadMmio8 = readSparse8;
+      xf86ReadMmio16 = readSparse16;
+      xf86ReadMmio32 = readSparse32;
+	
+      memBase = mmap((caddr_t)0, 0x100000000,
+		     PROT_READ | PROT_WRITE,
+		     MAP_SHARED, devMemFd,
+		     (off_t) BUS_BASE);
+      memSBase = mmap((caddr_t)0, 0x100000000,
+		      PROT_READ | PROT_WRITE,
+		      MAP_SHARED, devMemFd,
+		      (off_t) BUS_BASE_BWX);
+      
+      if (memSBase == MAP_FAILED || memBase == MAP_FAILED)	{
+	FatalError("xf86MapVidMem: Could not mmap framebuffer (%s)\n",
+		   strerror(errno));
+      }
+    }
+    return (pointer)((unsigned long)memBase + Base);
+}
+
+static void
+unmapVidMemSparse(int ScreenNum, pointer Base, unsigned long Size)
+{
+}
+
+static int
+readSparse8(pointer Base, register unsigned long Offset)
+{
+    register unsigned long result, shift;
+    register unsigned long msb;
+    mem_barrier();
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    shift = (Offset & 0x3) << 3;
+      if (Offset >= (hae_thresh)) {
+        msb = Offset & hae_mask;
+        Offset -= msb;
+	if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+	}
+      }
+    result = *(vuip) ((unsigned long)memSBase + (Offset << 5));
+    result >>= shift;
+    return 0xffUL & result;
+}
+
+static int
+readSparse16(pointer Base, register unsigned long Offset)
+{
+    register unsigned long result, shift;
+    register unsigned long msb;
+
+    mem_barrier();
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    shift = (Offset & 0x2) << 3;
+    if (Offset >= (hae_thresh)) {
+        msb = Offset & hae_mask;
+        Offset -= msb;
+      if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+      }
+    }
+    result = *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2)));
+    result >>= shift;
+    return 0xffffUL & result;
+}
+
+static int
+readSparse32(pointer Base, register unsigned long Offset)
+{
+    mem_barrier();
+    return *(vuip)((unsigned long)Base+(Offset));
+}
+
+static void
+writeSparse8(int Value, pointer Base, register unsigned long Offset)
+{
+    register unsigned long msb;
+    register unsigned int b = Value & 0xffU;
+
+    write_mem_barrier();
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    if (Offset >= (hae_thresh)) {
+      msb = Offset & hae_mask;
+      Offset -= msb;
+      if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+      }
+    }
+    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;
+}
+
+static void
+writeSparse16(int Value, pointer Base, register unsigned long Offset)
+{
+    register unsigned long msb;
+    register unsigned int w = Value & 0xffffU;
+
+    write_mem_barrier();
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    if (Offset >= (hae_thresh)) {
+      msb = Offset & hae_mask;
+      Offset -= msb;
+      if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+      }
+    }
+    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =
+      w * 0x00010001;
+
+}
+
+static void
+writeSparse32(int Value, pointer Base, register unsigned long Offset)
+{
+    write_mem_barrier();
+    *(vuip)((unsigned long)Base + (Offset)) = Value;
+    return;
+}
+
+static void
+writeSparseNB8(int Value, pointer Base, register unsigned long Offset)
+{
+    register unsigned long msb;
+    register unsigned int b = Value & 0xffU;
+
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    if (Offset >= (hae_thresh)) {
+      msb = Offset & hae_mask;
+      Offset -= msb;
+      if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+      }
+    }
+    *(vuip) ((unsigned long)memSBase + (Offset << 5)) = b * 0x01010101;
+}
+
+static void
+writeSparseNB16(int Value, pointer Base, register unsigned long Offset)
+{
+    register unsigned long msb;
+    register unsigned int w = Value & 0xffffU;
+
+    Offset += (unsigned long)Base - (unsigned long)memBase;
+    if (Offset >= (hae_thresh)) {
+      msb = Offset & hae_mask ;
+      Offset -= msb;
+      if (msb_set != msb) {
+#ifndef __NetBSD__
+	sethae(msb);
+#endif
+	msb_set = msb;
+      }
+    }
+    *(vuip)((unsigned long)memSBase+(Offset<<5)+(1<<(5-2))) =
+      w * 0x00010001;
+}
+
+static void
+writeSparseNB32(int Value, pointer Base, register unsigned long Offset)
+{
+    *(vuip)((unsigned long)Base + (Offset)) = Value;
+    return;
+}
+
+void (*xf86WriteMmio8)(int Value, pointer Base, unsigned long Offset)
+     = writeDense8;
+void (*xf86WriteMmio16)(int Value, pointer Base, unsigned long Offset)
+     = writeDense16;
+void (*xf86WriteMmio32)(int Value, pointer Base, unsigned long Offset)
+     = writeDense32;
+void (*xf86WriteMmioNB8)(int Value, pointer Base, unsigned long Offset)
+     = writeDenseNB8;
+void (*xf86WriteMmioNB16)(int Value, pointer Base, unsigned long Offset)
+     = writeDenseNB16;
+void (*xf86WriteMmioNB32)(int Value, pointer Base, unsigned long Offset)
+     = writeDenseNB32;
+int  (*xf86ReadMmio8)(pointer Base, unsigned long Offset)
+     = readDense8;
+int  (*xf86ReadMmio16)(pointer Base, unsigned long Offset)
+     = readDense16;
+int  (*xf86ReadMmio32)(pointer Base, unsigned long Offset)
+     = readDense32;
+
diff --git a/xorg-server/hw/xfree86/os-support/bsd/arm_video.c b/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
index 10cfee764..eb631a7f3 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/arm_video.c
@@ -1,666 +1,666 @@
-/*

- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

- * Copyright 1993 by David Wexelblat <dwex@goblin.org>

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the names of Rich Murphey and David Wexelblat 

- * not be used in advertising or publicity pertaining to distribution of 

- * the software without specific, written prior permission.  Rich Murphey and

- * David Wexelblat make no representations about the suitability of this 

- * software for any purpose.  It is provided "as is" without express or 

- * implied warranty.

- *

- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 

- * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 

- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 

- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- *

- */

-

-/*

- * The ARM32 code here carries the following copyright:

- *

- * Copyright 1997

- * Digital Equipment Corporation. All rights reserved.

- * This software is furnished under license and may be used and copied only in 

- * accordance with the following terms and conditions.  Subject to these

- * conditions, you may download, copy, install, use, modify and distribute

- * this software in source and/or binary form. No title or ownership is

- * transferred hereby.

- *

- * 1) Any source code used, modified or distributed must reproduce and retain

- *    this copyright notice and list of conditions as they appear in the

- *    source file.

- *

- * 2) No right is granted to use any trade name, trademark, or logo of Digital 

- *    Equipment Corporation. Neither the "Digital Equipment Corporation"

- *    name nor any trademark or logo of Digital Equipment Corporation may be

- *    used to endorse or promote products derived from this software without

- *    the prior written permission of Digital Equipment Corporation.

- *

- * 3) This software is provided "AS-IS" and any express or implied warranties,

- *    including but not limited to, any implied warranties of merchantability,

- *    fitness for a particular purpose, or non-infringement are disclaimed.

- *    In no event shall DIGITAL be liable for any damages whatsoever, and in

- *    particular, DIGITAL shall not be liable for special, indirect,

- *    consequential, or incidental damages or damages for lost profits, loss

- *    of revenue or loss of use, whether such damages arise in contract, 

- *    negligence, tort, under statute, in equity, at law or otherwise, even

- *    if advised of the possibility of such damage. 

- *

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <X11/X.h>

-#include "xf86.h"

-#include "xf86Priv.h"

-#include "xf86_OSlib.h"

-#include "xf86OSpriv.h"

-

-#ifdef __arm32__

-#include "machine/devmap.h"

-struct memAccess

-{

-    int ioctl;

-    struct map_info memInfo;

-    pointer regionVirtBase;

-    Bool Checked;

-    Bool OK;

-};

-

-static pointer xf86MapInfoMap();

-static void xf86MapInfoUnmap();

-static struct memAccess *checkMapInfo();

-extern int vgaPhysLinearBase;

-

-/* A memAccess structure is needed for each possible region */ 

-struct memAccess vgaMemInfo = { CONSOLE_GET_MEM_INFO, NULL, NULL, 

-				    FALSE, FALSE };

-struct memAccess linearMemInfo = { CONSOLE_GET_LINEAR_INFO, NULL, NULL, 

-				       FALSE, FALSE };

-struct memAccess ioMemInfo = { CONSOLE_GET_IO_INFO, NULL, NULL,

-				   FALSE, FALSE };

-#endif /* __arm32__ */

-

-#if defined(__NetBSD__) && !defined(MAP_FILE)

-#define MAP_FLAGS MAP_SHARED

-#else

-#define MAP_FLAGS (MAP_FILE | MAP_SHARED)

-#endif

-

-#ifndef MAP_FAILED

-#define MAP_FAILED ((caddr_t)-1)

-#endif

-

-

-#define BUS_BASE	0L

-#define BUS_BASE_BWX	0L

-

-

-/***************************************************************************/

-/* Video Memory Mapping section                                            */

-/***************************************************************************/

-

-static Bool useDevMem = FALSE;

-static int  devMemFd = -1;

-

-#define DEV_MEM "/dev/mem"

-

-static pointer mapVidMem(int, unsigned long, unsigned long, int);

-static void unmapVidMem(int, pointer, unsigned long);

-

-/*

- * Check if /dev/mem can be mmap'd.  If it can't print a warning when

- * "warn" is TRUE.

- */

-static void

-checkDevMem(Bool warn)

-{

-	static Bool devMemChecked = FALSE;

-	int fd;

-	pointer base;

-

-	if (devMemChecked)

-	    return;

-	devMemChecked = TRUE;

-

-	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)

-	{

-	    /* Try to map a page at the VGA address */

-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

-				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);

-	

-	    if (base != MAP_FAILED)

-	    {

-		munmap((caddr_t)base, 4096);

-		devMemFd = fd;

-		useDevMem = TRUE;

-		return;

-	    } else {

-		/* This should not happen */

-		if (warn)

-		{

-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

-			    DEV_MEM, strerror(errno));

-		}

-		useDevMem = FALSE;

-		return;

-	    }

-	}

-	if (warn)

-	{ 

-	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",

-		    DEV_MEM, strerror(errno));

-	} 

-	useDevMem = FALSE;

-	return;

-}

-

-void

-xf86OSInitVidMem(VidMemInfoPtr pVidMem)

-{

-

-	checkDevMem(TRUE);

-	pVidMem->linearSupported = useDevMem;

-	pVidMem->mapMem = armMapVidMem;

-	pVidMem->unmapVidMem = armUnmapVidMem;

-

-	pVidMem->initialised = TRUE;

-}

-

-static pointer

-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

-{

-	pointer base;

-

-	checkDevMem(FALSE);

-

-	if (useDevMem)

-	{

-	    if (devMemFd < 0) 

-	    {

-		FatalError("xf86MapVidMem: failed to open %s (%s)\n",

-			   DEV_MEM, strerror(errno));

-	    }

-	    base = mmap((caddr_t)0, Size,

-			(flags & VIDMEM_READONLY) ?

-			 PROT_READ : (PROT_READ | PROT_WRITE),

-			MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);

-	    if (base == MAP_FAILED)

-	    {

-		FatalError("%s: could not mmap %s [s=%x,a=%x] (%s)\n",

-			   "xf86MapVidMem", DEV_MEM, Size, Base, 

-			   strerror(errno));

-	    }

-	    return base;

-	}

-		

-	/* else, mmap /dev/vga */

-	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)

-	{

-		FatalError("%s: Address 0x%x outside allowable range\n",

-			   "xf86MapVidMem", Base);

-	}

-	base = mmap(0, Size,

-		    (flags & VIDMEM_READONLY) ?

-		     PROT_READ : (PROT_READ | PROT_WRITE),

-		    MAP_FLAGS, xf86Info.screenFd,

-		    (unsigned long)Base - 0xA0000);

-	if (base == MAP_FAILED)

-	{

-	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",

-		       strerror(errno));

-	}

-	return base;

-}

-

-static void

-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

-{

-	munmap((caddr_t)Base, Size);

-}

-

-/*

- * Read BIOS via mmap()ing DEV_MEM

- */

-

-int

-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

-	     int Len)

-{

-	unsigned char *ptr;

-	int psize;

-	int mlen;

-

-	checkDevMem(TRUE);

-	if (devMemFd == -1) {

-	    return -1;

-	}

-

-	psize = getpagesize();

-	Offset += Base & (psize - 1);

-	Base &= ~(psize - 1);

-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

-					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);

-	if ((long)ptr == -1)

-	{

-		xf86Msg(X_WARNING, 

-			"xf86ReadBIOS: %s mmap[s=%x,a=%x,o=%x] failed (%s)\n",

-			DEV_MEM, Len, Base, Offset, strerror(errno));

-		return -1;

-	}

-#ifdef DEBUG

-	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

-		Base, ptr[0] | (ptr[1] << 8));

-#endif

-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

-	(void)munmap((caddr_t)ptr, mlen);

-#ifdef DEBUG

-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"

-		"-> %02x %02x %02x %02x...\n",

-		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

-#endif

-	return Len;

-}

-

-

-/* XXX This needs to be updated for the ND */

-

-/*

-** Find out whether the console driver provides memory mapping information 

-** for the specified region and return the map_info pointer. Print a warning if required.

-*/

-static struct memAccess *

-checkMapInfo(Bool warn, int Region)

-{

-    struct memAccess *memAccP;

-        

-    switch (Region)

-    {

-	case VGA_REGION:

-	    memAccP = &vgaMemInfo;

-	    break;

-	    	    

-	case LINEAR_REGION:

-	    memAccP = &linearMemInfo;

-	    break;

-	    

-	case MMIO_REGION:

-	    memAccP = &ioMemInfo;

-	    break;

-	

-	default:

-	    return NULL;

-	    break;

-    }

-    

-    if(!memAccP->Checked)

-    {	

-	if(ioctl(xf86Info.screenFd, memAccP->ioctl, &(memAccP->memInfo)) == -1)

-	{

-	    if(warn)

-	    {

-		xf86Msg(X_WARNING,

-		 "checkMapInfo: failed to get map info for region %d\n\t(%s)\n",

-		       Region, strerror(errno));

-	    }

-	}

-	else

-	{

-	    if(memAccP->memInfo.u.map_info_mmap.map_offset 

-	       != MAP_INFO_UNKNOWN)

-		memAccP->OK = TRUE;

-	}

-	memAccP->Checked = TRUE;

-    }

-    if (memAccP->OK)

-    {

-	return memAccP;

-    }

-    else

-    {

-	return NULL;

-    }

-}

-

-static pointer

-xf86MapInfoMap(struct memAccess *memInfoP, pointer Base, unsigned long Size)

-{

-    struct map_info *mapInfoP = &(memInfoP->memInfo);

-

-    if (mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)

-    {	

-	Size = (unsigned long)Base + Size;

-    }

-    else

-    {

-	Size = mapInfoP->u.map_info_mmap.map_size;

-    }

-    

-    switch(mapInfoP->method)

-    {

-	case MAP_MMAP:

-	    /* Need to remap if size is unknown because we may not have

-	       mapped the whole region initially */

-	    if(memInfoP->regionVirtBase == NULL ||

-	       mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)

-	    {

-		if((memInfoP->regionVirtBase = 

-		    mmap((caddr_t)0,

-			 Size,

-			 PROT_READ | PROT_WRITE,

-			 MAP_SHARED,

-			 xf86Info.screenFd,

-			 (unsigned long)mapInfoP->u.map_info_mmap.map_offset))

-		   == (pointer)-1)

-		{

-		    FatalError("xf86MapInfoMap: Failed to map memory at 0x%x\n\t%s\n", 

-			       mapInfoP->u.map_info_mmap.map_offset, strerror(errno));

-		}

-		if(mapInfoP->u.map_info_mmap.internal_offset > 0)

-		    memInfoP->regionVirtBase += 

-			mapInfoP->u.map_info_mmap.internal_offset;

-	    }

-	    break;

-	    

-	default:

-	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");

-	    break;

-    }

-	    

-    return (pointer)((int)memInfoP->regionVirtBase + (int)Base);

-}

-

-static void

-xf86MapInfoUnmap(struct memAccess *memInfoP, unsigned long Size)

-{

-    struct map_info *mapInfoP = &(memInfoP->memInfo);

-    

-    switch(mapInfoP->method)

-    {

-	case MAP_MMAP:

-	    if(memInfoP->regionVirtBase != NULL)

-	    {

-		if(mapInfoP->u.map_info_mmap.map_size != MAP_INFO_UNKNOWN)

-		    Size = mapInfoP->u.map_info_mmap.map_size;

-		munmap((caddr_t)memInfoP->regionVirtBase, Size);

-		memInfoP->regionVirtBase = NULL;

-	    }

-	    break;

-	 default:

-	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");

-	    break;

-    }

-}

-

-static pointer

-armMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

-{

-	struct memAccess *memInfoP;

-	

-	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)

-	{

-	    /*

-	     ** xf86 passes in a physical address offset from the start

-	     ** of physical memory, but xf86MapInfoMap expects an 

-	     ** offset from the start of the specified region - it gets 

-	     ** the physical address of the region from the display driver.

-	     */

-	    switch(Region)

-	    {

-	        case LINEAR_REGION:

-		    if (vgaPhysLinearBase)

-		    {

-			Base -= vgaPhysLinearBase;

-		    }

-		    break;

-		case VGA_REGION:

-		    Base -= 0xA0000;

-		    break;

-	    }

-	    

-	    base = xf86MapInfoMap(memInfoP, Base, Size);

-	    return base;

-	}

-	return mapVidMem(ScreenNum, Base, Size, flags);

-}

-

-static void

-armUnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

-{

-        struct memAccess *memInfoP;

-	

-	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)

-	{

-	    xf86MapInfoUnmap(memInfoP, Base, Size);

-	}

-	unmapVidMem(ScreenNum, Base, Size);

-}

-

-#ifdef USE_DEV_IO

-static int IoFd = -1;

-

-Bool

-xf86EnableIO()

-{

-	if (IoFd >= 0)

-		return TRUE;

-

-	if ((IoFd = open("/dev/io", O_RDWR)) == -1)

-	{

-		xf86Msg(X_WARNING,"xf86EnableIO: "

-				"Failed to open /dev/io for extended I/O\n");

-		return FALSE;

-	}

-	return TRUE;

-}

-

-void

-xf86DisableIO()

-{

-	if (IoFd < 0)

-		return;

-

-	close(IoFd);

-	IoFd = -1;

-	return;

-}

-

-#endif

-

-#if defined(USE_ARC_MMAP) || defined(__arm32__)

-

-Bool

-xf86EnableIO()

-{

-	int fd;

-	pointer base;

-

-	if (ExtendedEnabled)

-		return TRUE;

-

-	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {

-		/* Try to map a page at the pccons I/O space */

-		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,

-				MAP_FLAGS, fd, (off_t)0x0000);

-

-		if (base != (pointer)-1) {

-			IOPortBase = base;

-		}

-		else {

-			xf86Msg(X_WARNING,"EnableIO: failed to mmap %s (%s)\n",

-				"/dev/ttyC0", strerror(errno));

-			return FALSE;

-		}

-	}

-	else {

-		xf86Msg("EnableIO: failed to open %s (%s)\n",

-			"/dev/ttyC0", strerror(errno));

-		return FALSE;

-	}

-	

-	ExtendedEnabled = TRUE;

-

-	return TRUE;

-}

-

-void

-xf86DisableIO()

-{

-	return;

-}

-

-#endif /* USE_ARC_MMAP */

-

-#if 0

-/*

- * XXX This is here for reference.  It needs to be handled differently for the

- * ND.

- */

-#if defined(USE_ARC_MMAP) || defined(__arm32__)

-

-#ifdef USE_ARM32_MMAP

-#define	DEV_MEM_IOBASE	0x43000000

-#endif

-

-static Bool ScreenEnabled[MAXSCREENS];

-static Bool ExtendedEnabled = FALSE;

-static Bool InitDone = FALSE;

-

-Bool

-xf86EnableIOPorts(ScreenNum)

-int ScreenNum;

-{

-	int i;

-	int fd;

-	pointer base;

-

-#ifdef __arm32__

-	struct memAccess *memInfoP;

-	int *Size;

-#endif

-

-	ScreenEnabled[ScreenNum] = TRUE;

-

-	if (ExtendedEnabled)

-		return TRUE;

-

-#ifdef USE_ARC_MMAP

-	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {

-		/* Try to map a page at the pccons I/O space */

-		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,

-				MAP_FLAGS, fd, (off_t)0x0000);

-

-		if (base != (pointer)-1) {

-			IOPortBase = base;

-		}

-		else {

-			xf86Msg(X_ERROR,

-				"EnableIOPorts: failed to mmap %s (%s)\n",

-				"/dev/ttyC0", strerror(errno));

-		}

-	}

-	else {

-		xf86Msg(X_ERROR, "EnableIOPorts: failed to open %s (%s)\n",

-			"/dev/ttyC0", strerror(errno));

-	}

-#endif

-

-#ifdef __arm32__

-	IOPortBase = (unsigned int)-1;

-

-	if((memInfoP = checkMapInfo(TRUE, MMIO_REGION)) != NULL)

-	{

-	    /* 

-	     * xf86MapInfoMap maps an offset from the start of video IO

-	     * space (e.g. 0x3B0), but IOPortBase is expected to map to

-	     * physical address 0x000, so subtract the start of video I/O

-	     * space from the result.  This is safe for now becase we

-	     * actually mmap the start of the page, then the start of video

-	     * I/O space is added as an internal offset.

-	     */

-	    IOPortBase = (unsigned int)xf86MapInfoMap(memInfoP,

-						      (caddr_t)0x0, 0L) 

-		- memInfoP->memInfo.u.map_info_mmap.internal_offset;

-	    ExtendedEnabled = TRUE;

-	    return TRUE;

-	}

-#ifdef USE_ARM32_MMAP

-	checkDevMem(TRUE);

-

-	if (devMemFd >= 0 && useDevMem)

-	{

-	    base = (pointer)mmap((caddr_t)0, 0x400, PROT_READ | PROT_WRITE,

-				 MAP_FLAGS, devMemFd, (off_t)DEV_MEM_IOBASE);

-

-	    if (base != (pointer)-1)

-		IOPortBase = (unsigned int)base;

-	}

-

-        if (IOPortBase == (unsigned int)-1)

-	{	

-	    xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\

-Make sure you have the Aperture Driver installed, or a kernel built with the INSECURE option\n");

-	    return FALSE;

-	}

-#else

-	/* We don't have the IOBASE, so we can't map the address */

-	xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\

-Try building the server with USE_ARM32_MMAP defined\n");

-	return FALSE;

-#endif

-#endif

-	

-	ExtendedEnabled = TRUE;

-

-	return TRUE;

-}

-

-void

-xf86DisableIOPorts(ScreenNum)

-int ScreenNum;

-{

-	int i;

-#ifdef __arm32__

-        struct memAccess *memInfoP;

-#endif

-

-	ScreenEnabled[ScreenNum] = FALSE;

-

-#ifdef __arm32__

-	if((memInfoP = checkMapInfo(FALSE, MMIO_REGION)) != NULL)

-	{

-	    xf86MapInfoUnmap(memInfoP, 0);

-	}

-#endif

-

-#ifdef USE_ARM32_MMAP

-	if (!ExtendedEnabled)

-	return;

-

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

-		if (ScreenEnabled[i])

-			return;

-

-	munmap((caddr_t)IOPortBase, 0x400);

-	IOPortBase = (unsigned int)-1;

-	ExtendedEnabled = FALSE;

-#endif

-

-	return;

-}

-

-#endif /* USE_ARC_MMAP || USE_ARM32_MMAP */

-#endif

-

-

+/*
+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Rich Murphey and David Wexelblat 
+ * not be used in advertising or publicity pertaining to distribution of 
+ * the software without specific, written prior permission.  Rich Murphey and
+ * David Wexelblat make no representations about the suitability of this 
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ *
+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+/*
+ * The ARM32 code here carries the following copyright:
+ *
+ * Copyright 1997
+ * Digital Equipment Corporation. All rights reserved.
+ * This software is furnished under license and may be used and copied only in 
+ * accordance with the following terms and conditions.  Subject to these
+ * conditions, you may download, copy, install, use, modify and distribute
+ * this software in source and/or binary form. No title or ownership is
+ * transferred hereby.
+ *
+ * 1) Any source code used, modified or distributed must reproduce and retain
+ *    this copyright notice and list of conditions as they appear in the
+ *    source file.
+ *
+ * 2) No right is granted to use any trade name, trademark, or logo of Digital 
+ *    Equipment Corporation. Neither the "Digital Equipment Corporation"
+ *    name nor any trademark or logo of Digital Equipment Corporation may be
+ *    used to endorse or promote products derived from this software without
+ *    the prior written permission of Digital Equipment Corporation.
+ *
+ * 3) This software is provided "AS-IS" and any express or implied warranties,
+ *    including but not limited to, any implied warranties of merchantability,
+ *    fitness for a particular purpose, or non-infringement are disclaimed.
+ *    In no event shall DIGITAL be liable for any damages whatsoever, and in
+ *    particular, DIGITAL shall not be liable for special, indirect,
+ *    consequential, or incidental damages or damages for lost profits, loss
+ *    of revenue or loss of use, whether such damages arise in contract, 
+ *    negligence, tort, under statute, in equity, at law or otherwise, even
+ *    if advised of the possibility of such damage. 
+ *
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86OSpriv.h"
+
+#ifdef __arm32__
+#include "machine/devmap.h"
+struct memAccess
+{
+    int ioctl;
+    struct map_info memInfo;
+    pointer regionVirtBase;
+    Bool Checked;
+    Bool OK;
+};
+
+static pointer xf86MapInfoMap();
+static void xf86MapInfoUnmap();
+static struct memAccess *checkMapInfo();
+extern int vgaPhysLinearBase;
+
+/* A memAccess structure is needed for each possible region */ 
+struct memAccess vgaMemInfo = { CONSOLE_GET_MEM_INFO, NULL, NULL, 
+				    FALSE, FALSE };
+struct memAccess linearMemInfo = { CONSOLE_GET_LINEAR_INFO, NULL, NULL, 
+				       FALSE, FALSE };
+struct memAccess ioMemInfo = { CONSOLE_GET_IO_INFO, NULL, NULL,
+				   FALSE, FALSE };
+#endif /* __arm32__ */
+
+#if defined(__NetBSD__) && !defined(MAP_FILE)
+#define MAP_FLAGS MAP_SHARED
+#else
+#define MAP_FLAGS (MAP_FILE | MAP_SHARED)
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((caddr_t)-1)
+#endif
+
+
+#define BUS_BASE	0L
+#define BUS_BASE_BWX	0L
+
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+static Bool useDevMem = FALSE;
+static int  devMemFd = -1;
+
+#define DEV_MEM "/dev/mem"
+
+static pointer mapVidMem(int, unsigned long, unsigned long, int);
+static void unmapVidMem(int, pointer, unsigned long);
+
+/*
+ * Check if /dev/mem can be mmap'd.  If it can't print a warning when
+ * "warn" is TRUE.
+ */
+static void
+checkDevMem(Bool warn)
+{
+	static Bool devMemChecked = FALSE;
+	int fd;
+	pointer base;
+
+	if (devMemChecked)
+	    return;
+	devMemChecked = TRUE;
+
+	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)
+	{
+	    /* Try to map a page at the VGA address */
+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
+				 MAP_FLAGS, fd, (off_t)0xA0000 + BUS_BASE);
+	
+	    if (base != MAP_FAILED)
+	    {
+		munmap((caddr_t)base, 4096);
+		devMemFd = fd;
+		useDevMem = TRUE;
+		return;
+	    } else {
+		/* This should not happen */
+		if (warn)
+		{
+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
+			    DEV_MEM, strerror(errno));
+		}
+		useDevMem = FALSE;
+		return;
+	    }
+	}
+	if (warn)
+	{ 
+	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",
+		    DEV_MEM, strerror(errno));
+	} 
+	useDevMem = FALSE;
+	return;
+}
+
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+
+	checkDevMem(TRUE);
+	pVidMem->linearSupported = useDevMem;
+	pVidMem->mapMem = armMapVidMem;
+	pVidMem->unmapVidMem = armUnmapVidMem;
+
+	pVidMem->initialised = TRUE;
+}
+
+static pointer
+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+	pointer base;
+
+	checkDevMem(FALSE);
+
+	if (useDevMem)
+	{
+	    if (devMemFd < 0) 
+	    {
+		FatalError("xf86MapVidMem: failed to open %s (%s)\n",
+			   DEV_MEM, strerror(errno));
+	    }
+	    base = mmap((caddr_t)0, Size,
+			(flags & VIDMEM_READONLY) ?
+			 PROT_READ : (PROT_READ | PROT_WRITE),
+			MAP_FLAGS, devMemFd, (off_t)Base + BUS_BASE_BWX);
+	    if (base == MAP_FAILED)
+	    {
+		FatalError("%s: could not mmap %s [s=%x,a=%x] (%s)\n",
+			   "xf86MapVidMem", DEV_MEM, Size, Base, 
+			   strerror(errno));
+	    }
+	    return base;
+	}
+		
+	/* else, mmap /dev/vga */
+	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)
+	{
+		FatalError("%s: Address 0x%x outside allowable range\n",
+			   "xf86MapVidMem", Base);
+	}
+	base = mmap(0, Size,
+		    (flags & VIDMEM_READONLY) ?
+		     PROT_READ : (PROT_READ | PROT_WRITE),
+		    MAP_FLAGS, xf86Info.consoleFd,
+		    (unsigned long)Base - 0xA0000);
+	if (base == MAP_FAILED)
+	{
+	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)\n",
+		       strerror(errno));
+	}
+	return base;
+}
+
+static void
+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+	munmap((caddr_t)Base, Size);
+}
+
+/*
+ * Read BIOS via mmap()ing DEV_MEM
+ */
+
+int
+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
+	     int Len)
+{
+	unsigned char *ptr;
+	int psize;
+	int mlen;
+
+	checkDevMem(TRUE);
+	if (devMemFd == -1) {
+	    return -1;
+	}
+
+	psize = getpagesize();
+	Offset += Base & (psize - 1);
+	Base &= ~(psize - 1);
+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
+					MAP_SHARED, devMemFd, (off_t)Base+BUS_BASE);
+	if ((long)ptr == -1)
+	{
+		xf86Msg(X_WARNING, 
+			"xf86ReadBIOS: %s mmap[s=%x,a=%x,o=%x] failed (%s)\n",
+			DEV_MEM, Len, Base, Offset, strerror(errno));
+		return -1;
+	}
+#ifdef DEBUG
+	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
+		Base, ptr[0] | (ptr[1] << 8));
+#endif
+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
+	(void)munmap((caddr_t)ptr, mlen);
+#ifdef DEBUG
+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"
+		"-> %02x %02x %02x %02x...\n",
+		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);
+#endif
+	return Len;
+}
+
+
+/* XXX This needs to be updated for the ND */
+
+/*
+** Find out whether the console driver provides memory mapping information 
+** for the specified region and return the map_info pointer. Print a warning if required.
+*/
+static struct memAccess *
+checkMapInfo(Bool warn, int Region)
+{
+    struct memAccess *memAccP;
+        
+    switch (Region)
+    {
+	case VGA_REGION:
+	    memAccP = &vgaMemInfo;
+	    break;
+	    	    
+	case LINEAR_REGION:
+	    memAccP = &linearMemInfo;
+	    break;
+	    
+	case MMIO_REGION:
+	    memAccP = &ioMemInfo;
+	    break;
+	
+	default:
+	    return NULL;
+	    break;
+    }
+    
+    if(!memAccP->Checked)
+    {	
+	if(ioctl(xf86Info.consoleFd, memAccP->ioctl, &(memAccP->memInfo)) == -1)
+	{
+	    if(warn)
+	    {
+		xf86Msg(X_WARNING,
+		 "checkMapInfo: failed to get map info for region %d\n\t(%s)\n",
+		       Region, strerror(errno));
+	    }
+	}
+	else
+	{
+	    if(memAccP->memInfo.u.map_info_mmap.map_offset 
+	       != MAP_INFO_UNKNOWN)
+		memAccP->OK = TRUE;
+	}
+	memAccP->Checked = TRUE;
+    }
+    if (memAccP->OK)
+    {
+	return memAccP;
+    }
+    else
+    {
+	return NULL;
+    }
+}
+
+static pointer
+xf86MapInfoMap(struct memAccess *memInfoP, pointer Base, unsigned long Size)
+{
+    struct map_info *mapInfoP = &(memInfoP->memInfo);
+
+    if (mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)
+    {	
+	Size = (unsigned long)Base + Size;
+    }
+    else
+    {
+	Size = mapInfoP->u.map_info_mmap.map_size;
+    }
+    
+    switch(mapInfoP->method)
+    {
+	case MAP_MMAP:
+	    /* Need to remap if size is unknown because we may not have
+	       mapped the whole region initially */
+	    if(memInfoP->regionVirtBase == NULL ||
+	       mapInfoP->u.map_info_mmap.map_size == MAP_INFO_UNKNOWN)
+	    {
+		if((memInfoP->regionVirtBase = 
+		    mmap((caddr_t)0,
+			 Size,
+			 PROT_READ | PROT_WRITE,
+			 MAP_SHARED,
+			 xf86Info.consoleFd,
+			 (unsigned long)mapInfoP->u.map_info_mmap.map_offset))
+		   == (pointer)-1)
+		{
+		    FatalError("xf86MapInfoMap: Failed to map memory at 0x%x\n\t%s\n", 
+			       mapInfoP->u.map_info_mmap.map_offset, strerror(errno));
+		}
+		if(mapInfoP->u.map_info_mmap.internal_offset > 0)
+		    memInfoP->regionVirtBase += 
+			mapInfoP->u.map_info_mmap.internal_offset;
+	    }
+	    break;
+	    
+	default:
+	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");
+	    break;
+    }
+	    
+    return (pointer)((int)memInfoP->regionVirtBase + (int)Base);
+}
+
+static void
+xf86MapInfoUnmap(struct memAccess *memInfoP, unsigned long Size)
+{
+    struct map_info *mapInfoP = &(memInfoP->memInfo);
+    
+    switch(mapInfoP->method)
+    {
+	case MAP_MMAP:
+	    if(memInfoP->regionVirtBase != NULL)
+	    {
+		if(mapInfoP->u.map_info_mmap.map_size != MAP_INFO_UNKNOWN)
+		    Size = mapInfoP->u.map_info_mmap.map_size;
+		munmap((caddr_t)memInfoP->regionVirtBase, Size);
+		memInfoP->regionVirtBase = NULL;
+	    }
+	    break;
+	 default:
+	    FatalError("xf86MapInfoMap: Unsuported mapping method\n");
+	    break;
+    }
+}
+
+static pointer
+armMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+	struct memAccess *memInfoP;
+	
+	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)
+	{
+	    /*
+	     ** xf86 passes in a physical address offset from the start
+	     ** of physical memory, but xf86MapInfoMap expects an 
+	     ** offset from the start of the specified region - it gets 
+	     ** the physical address of the region from the display driver.
+	     */
+	    switch(Region)
+	    {
+	        case LINEAR_REGION:
+		    if (vgaPhysLinearBase)
+		    {
+			Base -= vgaPhysLinearBase;
+		    }
+		    break;
+		case VGA_REGION:
+		    Base -= 0xA0000;
+		    break;
+	    }
+	    
+	    base = xf86MapInfoMap(memInfoP, Base, Size);
+	    return base;
+	}
+	return mapVidMem(ScreenNum, Base, Size, flags);
+}
+
+static void
+armUnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+        struct memAccess *memInfoP;
+	
+	if((memInfoP = checkMapInfo(FALSE, Region)) != NULL)
+	{
+	    xf86MapInfoUnmap(memInfoP, Base, Size);
+	}
+	unmapVidMem(ScreenNum, Base, Size);
+}
+
+#ifdef USE_DEV_IO
+static int IoFd = -1;
+
+Bool
+xf86EnableIO()
+{
+	if (IoFd >= 0)
+		return TRUE;
+
+	if ((IoFd = open("/dev/io", O_RDWR)) == -1)
+	{
+		xf86Msg(X_WARNING,"xf86EnableIO: "
+				"Failed to open /dev/io for extended I/O\n");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+void
+xf86DisableIO()
+{
+	if (IoFd < 0)
+		return;
+
+	close(IoFd);
+	IoFd = -1;
+	return;
+}
+
+#endif
+
+#if defined(USE_ARC_MMAP) || defined(__arm32__)
+
+Bool
+xf86EnableIO()
+{
+	int fd;
+	pointer base;
+
+	if (ExtendedEnabled)
+		return TRUE;
+
+	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {
+		/* Try to map a page at the pccons I/O space */
+		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,
+				MAP_FLAGS, fd, (off_t)0x0000);
+
+		if (base != (pointer)-1) {
+			IOPortBase = base;
+		}
+		else {
+			xf86Msg(X_WARNING,"EnableIO: failed to mmap %s (%s)\n",
+				"/dev/ttyC0", strerror(errno));
+			return FALSE;
+		}
+	}
+	else {
+		xf86Msg("EnableIO: failed to open %s (%s)\n",
+			"/dev/ttyC0", strerror(errno));
+		return FALSE;
+	}
+	
+	ExtendedEnabled = TRUE;
+
+	return TRUE;
+}
+
+void
+xf86DisableIO()
+{
+	return;
+}
+
+#endif /* USE_ARC_MMAP */
+
+#if 0
+/*
+ * XXX This is here for reference.  It needs to be handled differently for the
+ * ND.
+ */
+#if defined(USE_ARC_MMAP) || defined(__arm32__)
+
+#ifdef USE_ARM32_MMAP
+#define	DEV_MEM_IOBASE	0x43000000
+#endif
+
+static Bool ScreenEnabled[MAXSCREENS];
+static Bool ExtendedEnabled = FALSE;
+static Bool InitDone = FALSE;
+
+Bool
+xf86EnableIOPorts(ScreenNum)
+int ScreenNum;
+{
+	int i;
+	int fd;
+	pointer base;
+
+#ifdef __arm32__
+	struct memAccess *memInfoP;
+	int *Size;
+#endif
+
+	ScreenEnabled[ScreenNum] = TRUE;
+
+	if (ExtendedEnabled)
+		return TRUE;
+
+#ifdef USE_ARC_MMAP
+	if ((fd = open("/dev/ttyC0", O_RDWR)) >= 0) {
+		/* Try to map a page at the pccons I/O space */
+		base = (pointer)mmap((caddr_t)0, 65536, PROT_READ | PROT_WRITE,
+				MAP_FLAGS, fd, (off_t)0x0000);
+
+		if (base != (pointer)-1) {
+			IOPortBase = base;
+		}
+		else {
+			xf86Msg(X_ERROR,
+				"EnableIOPorts: failed to mmap %s (%s)\n",
+				"/dev/ttyC0", strerror(errno));
+		}
+	}
+	else {
+		xf86Msg(X_ERROR, "EnableIOPorts: failed to open %s (%s)\n",
+			"/dev/ttyC0", strerror(errno));
+	}
+#endif
+
+#ifdef __arm32__
+	IOPortBase = (unsigned int)-1;
+
+	if((memInfoP = checkMapInfo(TRUE, MMIO_REGION)) != NULL)
+	{
+	    /* 
+	     * xf86MapInfoMap maps an offset from the start of video IO
+	     * space (e.g. 0x3B0), but IOPortBase is expected to map to
+	     * physical address 0x000, so subtract the start of video I/O
+	     * space from the result.  This is safe for now becase we
+	     * actually mmap the start of the page, then the start of video
+	     * I/O space is added as an internal offset.
+	     */
+	    IOPortBase = (unsigned int)xf86MapInfoMap(memInfoP,
+						      (caddr_t)0x0, 0L) 
+		- memInfoP->memInfo.u.map_info_mmap.internal_offset;
+	    ExtendedEnabled = TRUE;
+	    return TRUE;
+	}
+#ifdef USE_ARM32_MMAP
+	checkDevMem(TRUE);
+
+	if (devMemFd >= 0 && useDevMem)
+	{
+	    base = (pointer)mmap((caddr_t)0, 0x400, PROT_READ | PROT_WRITE,
+				 MAP_FLAGS, devMemFd, (off_t)DEV_MEM_IOBASE);
+
+	    if (base != (pointer)-1)
+		IOPortBase = (unsigned int)base;
+	}
+
+        if (IOPortBase == (unsigned int)-1)
+	{	
+	    xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\
+Make sure you have the Aperture Driver installed, or a kernel built with the INSECURE option\n");
+	    return FALSE;
+	}
+#else
+	/* We don't have the IOBASE, so we can't map the address */
+	xf86Msg(X_WARNING,"xf86EnableIOPorts: failed to open mem device or map IO base. \n\
+Try building the server with USE_ARM32_MMAP defined\n");
+	return FALSE;
+#endif
+#endif
+	
+	ExtendedEnabled = TRUE;
+
+	return TRUE;
+}
+
+void
+xf86DisableIOPorts(ScreenNum)
+int ScreenNum;
+{
+	int i;
+#ifdef __arm32__
+        struct memAccess *memInfoP;
+#endif
+
+	ScreenEnabled[ScreenNum] = FALSE;
+
+#ifdef __arm32__
+	if((memInfoP = checkMapInfo(FALSE, MMIO_REGION)) != NULL)
+	{
+	    xf86MapInfoUnmap(memInfoP, 0);
+	}
+#endif
+
+#ifdef USE_ARM32_MMAP
+	if (!ExtendedEnabled)
+	return;
+
+	for (i = 0; i < MAXSCREENS; i++)
+		if (ScreenEnabled[i])
+			return;
+
+	munmap((caddr_t)IOPortBase, 0x400);
+	IOPortBase = (unsigned int)-1;
+	ExtendedEnabled = FALSE;
+#endif
+
+	return;
+}
+
+#endif /* USE_ARC_MMAP || USE_ARM32_MMAP */
+#endif
+
+
diff --git a/xorg-server/hw/xfree86/os-support/bsd/bsd_bell.c b/xorg-server/hw/xfree86/os-support/bsd/bsd_bell.c
index 55eb75231..fb457db71 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/bsd_bell.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/bsd_bell.c
@@ -37,10 +37,6 @@
 #include "xf86Priv.h"
 #include "xf86_OSlib.h"
 
-#ifdef WSCONS_SUPPORT
-#define KBD_FD(i) ((i).kbdFd != -1 ? (i).kbdFd : (i).consoleFd)
-#endif
-
 void
 xf86OSRingBell(int loudness, int pitch, int duration)
 {
diff --git a/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c b/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
index 837a2f4d1..844617980 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/bsd_init.c
@@ -41,7 +41,10 @@
 #include <errno.h>
 
 static Bool KeepTty = FALSE;
+
+#ifdef PCCONS_SUPPORT
 static int devConsoleFd = -1;
+#endif
 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT)
 static int VTnum = -1;
 static int initialVT = -1;
@@ -207,11 +210,7 @@ xf86OpenConsole()
 		"%s: No console driver found\n\tSupported drivers: %s\n\t%s",
 		"xf86OpenConsole", cons_drivers, CHECK_DRIVER_MSG);
 	}
-#if 0 /* stdin is already closed in OsInit() */
-	fclose(stdin);
-#endif
 	xf86Info.consoleFd = fd;
-	xf86Info.screenFd = fd;
 
 	switch (xf86Info.consType)
 	{
@@ -292,13 +291,13 @@ acquire_vt:
 		    {
 			FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed");
 		    }
-	#if !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
+#if !defined(__OpenBSD__) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
 		    if (ioctl(xf86Info.consoleFd, KDENABIO, 0) < 0)
 		    {
 			FatalError("xf86OpenConsole: KDENABIO failed (%s)",
 				   strerror(errno));
 		    }
-	#endif
+#endif
 		    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0)
 		    {
 			FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed");
@@ -370,7 +369,6 @@ xf86OpenSyscons()
     int fd = -1;
     vtmode_t vtmode;
     char vtname[12];
-    struct stat status;
     long syscons_version;
     MessageType from;
 
@@ -423,20 +421,11 @@ xf86OpenSyscons()
 		{
 		    /*
 		     * All VTs are in use.  If initialVT was found, use it.
-		     * Otherwise, if stdin is a VT, use that one.
-		     * XXX stdin is already closed, so this won't work.
 		     */
 		    if (initialVT != -1)
 		    {
 			xf86Info.vtno = initialVT;
 		    }
-		    else if ((fstat(0, &status) >= 0)
-			     && S_ISCHR(status.st_mode)
-			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
-		    {
-			/* stdin is a VT */
-			xf86Info.vtno = minor(status.st_rdev) + 1;
-		    }
 		    else
 		    {
 			if (syscons_version >= 0x100)
@@ -457,11 +446,7 @@ xf86OpenSyscons()
 	    }
 
 	    close(fd);
-#ifndef __OpenBSD__
 	    sprintf(vtname, "/dev/ttyv%01x", xf86Info.vtno - 1);
-#else 
-	    sprintf(vtname, "/dev/ttyC%01x", xf86Info.vtno - 1);
-#endif	    
 	    if ((fd = open(vtname, SYSCONS_CONSOLE_MODE, 0)) < 0)
 	    {
 		FatalError("xf86OpenSyscons: Cannot open %s (%s)",
@@ -506,7 +491,6 @@ xf86OpenPcvt()
     int fd = -1;
     vtmode_t vtmode;
     char vtname[12], *vtprefix;
-    struct stat status;
     struct pcvtid pcvt_version;
 
 #ifndef __OpenBSD__
@@ -552,20 +536,11 @@ xf86OpenPcvt()
 		{
 		    /*
 		     * All VTs are in use.  If initialVT was found, use it.
-		     * Otherwise, if stdin is a VT, use that one.
-		     * XXX stdin is already closed, so this won't work.
 		     */
 		    if (initialVT != -1)
 		    {
 			xf86Info.vtno = initialVT;
 		    }
-		    else if ((fstat(0, &status) >= 0)
-			     && S_ISCHR(status.st_mode)
-			     && (ioctl(0, VT_GETMODE, &vtmode) >= 0))
-		    {
-			/* stdin is a VT */
-			xf86Info.vtno = minor(status.st_rdev) + 1;
-		    }
 		    else
 		    {
 			FatalError("%s: Cannot find a free VT",
@@ -673,7 +648,7 @@ xf86CloseConsole()
 	    VT.mode = VT_AUTO;
 	    ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* dflt vt handling */
         }
-#if !defined(OpenBSD) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
+#if !defined(__OpenBSD__) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL)
         if (ioctl(xf86Info.consoleFd, KDDISABIO, 0) < 0)
         {
             xf86FatalError("xf86CloseConsole: KDDISABIO failed (%s)",
@@ -688,25 +663,17 @@ xf86CloseConsole()
     case WSCONS:
       {
 	int mode = WSDISPLAYIO_MODE_EMUL;
-	ioctl(xf86Info.screenFd, WSDISPLAYIO_SMODE, &mode);
+	ioctl(xf86Info.consoleFd, WSDISPLAYIO_SMODE, &mode);
 	break;
       }
 #endif
     }
 
-    if (xf86Info.screenFd != xf86Info.consoleFd)
-    {
-	close(xf86Info.screenFd);
-	close(xf86Info.consoleFd);
-	if ((xf86Info.consoleFd = open("/dev/console",O_RDONLY,0)) <0)
-	{
-	    xf86FatalError("xf86CloseConsole: Cannot open /dev/console (%s)",
-			   strerror(errno));
-	}
-    }
     close(xf86Info.consoleFd);
+#ifdef PCCONS_SUPPORT
     if (devConsoleFd >= 0)
 	close(devConsoleFd);
+#endif
     return;
 }
 
diff --git a/xorg-server/hw/xfree86/os-support/bsd/i386_video.c b/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
index 9b26fb1dd..525bfb607 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/i386_video.c
@@ -1,908 +1,908 @@
-/*

- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

- * Copyright 1993 by David Wexelblat <dwex@goblin.org>

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the names of Rich Murphey and David Wexelblat 

- * not be used in advertising or publicity pertaining to distribution of 

- * the software without specific, written prior permission.  Rich Murphey and

- * David Wexelblat make no representations about the suitability of this 

- * software for any purpose.  It is provided "as is" without express or 

- * implied warranty.

- *

- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 

- * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 

- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 

- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- *

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <X11/X.h>

-#include "xf86.h"

-#include "xf86Priv.h"

-

-#include <errno.h>

-#include <sys/mman.h>

-

-#ifdef HAS_MTRR_SUPPORT

-#ifndef __NetBSD__

-#include <sys/types.h>

-#include <sys/memrange.h>

-#else

-#include "memrange.h"

-#endif

-#define X_MTRR_ID "XFree86"

-#endif

-

-#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)

-#include <machine/mtrr.h>

-#include <machine/sysarch.h>

-#include <sys/queue.h>

-#ifdef __x86_64__

-#define i386_set_mtrr x86_64_set_mtrr

-#define i386_get_mtrr x86_64_get_mtrr

-#define i386_iopl x86_64_iopl

-#endif

-#endif

-

-#include "xf86_OSlib.h"

-#include "xf86OSpriv.h"

-

-#if defined(__NetBSD__) && !defined(MAP_FILE)

-#define MAP_FLAGS MAP_SHARED

-#else

-#define MAP_FLAGS (MAP_FILE | MAP_SHARED)

-#endif

-

-#ifndef MAP_FAILED

-#define MAP_FAILED ((caddr_t)-1)

-#endif

-

-#ifdef __OpenBSD__

-#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\

-		   "\tin /etc/sysctl.conf and reboot your machine\n" \

-		   "\trefer to xf86(4) for details"

-#define SYSCTL_MSG2 \

-		"Check that you have set 'machdep.allowaperture=2'\n" \

-		"\tin /etc/sysctl.conf and reboot your machine\n" \

-		"\trefer to xf86(4) for details"

-#endif

-

-/***************************************************************************/

-/* Video Memory Mapping section                                            */

-/***************************************************************************/

-

-static Bool useDevMem = FALSE;

-static int  devMemFd = -1;

-

-#ifdef HAS_APERTURE_DRV

-#define DEV_APERTURE "/dev/xf86"

-#endif

-#define DEV_MEM "/dev/mem"

-

-static pointer mapVidMem(int, unsigned long, unsigned long, int);

-static void unmapVidMem(int, pointer, unsigned long);

-

-#ifdef HAS_MTRR_SUPPORT

-static pointer setWC(int, unsigned long, unsigned long, Bool, MessageType);

-static void undoWC(int, pointer);

-static Bool cleanMTRR(void);

-#endif

-#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)

-static pointer NetBSDsetWC(int, unsigned long, unsigned long, Bool,

-			   MessageType);

-static void NetBSDundoWC(int, pointer);

-#endif

-

-/*

- * Check if /dev/mem can be mmap'd.  If it can't print a warning when

- * "warn" is TRUE.

- */

-static void

-checkDevMem(Bool warn)

-{

-	static Bool devMemChecked = FALSE;

-	int fd;

-	pointer base;

-

-	if (devMemChecked)

-	    return;

-	devMemChecked = TRUE;

-

-	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)

-	{

-	    /* Try to map a page at the VGA address */

-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

-				 MAP_FLAGS, fd, (off_t)0xA0000);

-	

-	    if (base != MAP_FAILED)

-	    {

-		munmap((caddr_t)base, 4096);

-		devMemFd = fd;

-		useDevMem = TRUE;

-		return;

-	    } else {

-		/* This should not happen */

-		if (warn)

-		{

-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

-			    DEV_MEM, strerror(errno));

-		}

-		useDevMem = FALSE;

-		return;

-	    }

-	}

-#ifndef HAS_APERTURE_DRV

-	if (warn)

-	{ 

-	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",

-		    DEV_MEM, strerror(errno));

-	} 

-	useDevMem = FALSE;

-	return;

-#else

-	/* Failed to open /dev/mem, try the aperture driver */

-	if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0)

-	{

-	    /* Try to map a page at the VGA address */

-	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,

-			     MAP_FLAGS, fd, (off_t)0xA0000);

-	

-	    if (base != MAP_FAILED)

-	    {

-		munmap((caddr_t)base, 4096);

-		devMemFd = fd;

-		useDevMem = TRUE;

-		xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",

-		        DEV_APERTURE);

-		return;

-	    } else {

-

-		if (warn)

-		{

-		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",

-			    DEV_APERTURE, strerror(errno));

-		}

-	    }

-	} else {

-	    if (warn)

-	    {

-#ifndef __OpenBSD__

-		xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

-			"\t(%s)\n", DEV_MEM, DEV_APERTURE, strerror(errno));

-#else /* __OpenBSD__ */

-		xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"

-			"\t(%s)\n%s", DEV_MEM, DEV_APERTURE, strerror(errno),

-			SYSCTL_MSG);

-#endif /* __OpenBSD__ */

-	    }

-	}

-	

-	useDevMem = FALSE;

-	return;

-

-#endif

-}

-

-void

-xf86OSInitVidMem(VidMemInfoPtr pVidMem)

-{

-	checkDevMem(TRUE);

-	pVidMem->linearSupported = useDevMem;

-	pVidMem->mapMem = mapVidMem;

-	pVidMem->unmapMem = unmapVidMem;

-

-#if HAVE_PCI_SYSTEM_INIT_DEV_MEM

-	if (useDevMem)

-		pci_system_init_dev_mem(devMemFd);

-#endif

-

-#ifdef HAS_MTRR_SUPPORT

-	if (useDevMem) {

-		if (cleanMTRR()) {

-			pVidMem->setWC = setWC;

-			pVidMem->undoWC = undoWC;

-		}

-	}

-#endif

-#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)

-	pVidMem->setWC = NetBSDsetWC;

-	pVidMem->undoWC = NetBSDundoWC;

-#endif

-	pVidMem->initialised = TRUE;

-}

-

-static pointer

-mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)

-{

-	pointer base;

-

-	checkDevMem(FALSE);

-

-	if (useDevMem)

-	{

-	    if (devMemFd < 0) 

-	    {

-		FatalError("xf86MapVidMem: failed to open %s (%s)",

-			   DEV_MEM, strerror(errno));

-	    }

-	    base = mmap((caddr_t)0, Size,

-			(flags & VIDMEM_READONLY) ?

-			 PROT_READ : (PROT_READ | PROT_WRITE),

-			MAP_FLAGS, devMemFd, (off_t)Base);

-	    if (base == MAP_FAILED)

-	    {

-		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)",

-			   "xf86MapVidMem", DEV_MEM, Size, Base, 

-			   strerror(errno));

-	    }

-	    return base;

-	}

-		

-	/* else, mmap /dev/vga */

-	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)

-	{

-		FatalError("%s: Address 0x%lx outside allowable range",

-			   "xf86MapVidMem", Base);

-	}

-	base = mmap(0, Size,

-		    (flags & VIDMEM_READONLY) ?

-		     PROT_READ : (PROT_READ | PROT_WRITE),

-		    MAP_FLAGS, xf86Info.screenFd,

-		    (unsigned long)Base - 0xA0000

-	    );

-	if (base == MAP_FAILED)

-	{

-	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)",

-		       strerror(errno));

-	}

-	return base;

-}

-

-static void

-unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

-{

-	munmap((caddr_t)Base, Size);

-}

-

-/*

- * Read BIOS via mmap()ing DEV_MEM

- */

-

-int

-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

-	     int Len)

-{

-	unsigned char *ptr;

-	int psize;

-	int mlen;

-

-	checkDevMem(TRUE);

-	if (devMemFd == -1) {

-	    return -1;

-	}

-

-	psize = getpagesize();

-	Offset += Base & (psize - 1);

-	Base &= ~(psize - 1);

-	mlen = (Offset + Len + psize - 1) & ~(psize - 1);

-	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,

-					MAP_SHARED, devMemFd, (off_t)Base);

-	if ((long)ptr == -1)

-	{

-		xf86Msg(X_WARNING, 

-			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",

-			DEV_MEM, Len, Base, Offset, strerror(errno));

-#ifdef __OpenBSD__

-		if (Base < 0xa0000) {

-		    xf86Msg(X_WARNING, SYSCTL_MSG2);

-		} 

-#endif

-		return -1;

-	}

-#ifdef DEBUG

-	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",

-		Base, ptr[0] | (ptr[1] << 8));

-#endif

-	(void)memcpy(Buf, (void *)(ptr + Offset), Len);

-	(void)munmap((caddr_t)ptr, mlen);

-#ifdef DEBUG

-	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"

-		"-> %02x %02x %02x %02x...\n",

-		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);

-#endif

-	return Len;

-}

-

-#ifdef USE_I386_IOPL

-/***************************************************************************/

-/* I/O Permissions section                                                 */

-/***************************************************************************/

-

-static Bool ExtendedEnabled = FALSE;

-

-Bool

-xf86EnableIO()

-{

-	if (ExtendedEnabled)

-		return TRUE;

-

-	if (i386_iopl(TRUE) < 0)

-	{

-#ifndef __OpenBSD__

-		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O",

-			   "xf86EnableIO");

-#else

-		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O\n%s",

-			   "xf86EnableIO", SYSCTL_MSG);

-#endif

-		return FALSE;

-	}

-	ExtendedEnabled = TRUE;

-

-	return TRUE;

-}

-	

-void

-xf86DisableIO()

-{

-	if (!ExtendedEnabled)

-		return;

-

-	i386_iopl(FALSE);

-	ExtendedEnabled = FALSE;

-

-	return;

-}

-

-#endif /* USE_I386_IOPL */

-

-#ifdef USE_AMD64_IOPL

-/***************************************************************************/

-/* I/O Permissions section                                                 */

-/***************************************************************************/

-

-static Bool ExtendedEnabled = FALSE;

-

-Bool

-xf86EnableIO()

-{

-	if (ExtendedEnabled)

-		return TRUE;

-

-	if (amd64_iopl(TRUE) < 0)

-	{

-#ifndef __OpenBSD__

-		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O",

-			   "xf86EnableIO");

-#else

-		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O\n%s",

-			   "xf86EnableIO", SYSCTL_MSG);

-#endif

-		return FALSE;

-	}

-	ExtendedEnabled = TRUE;

-

-	return TRUE;

-}

-	

-void

-xf86DisableIO()

-{

-	if (!ExtendedEnabled)

-		return;

-

-	if (amd64_iopl(FALSE) == 0) {

-		ExtendedEnabled = FALSE;

-	}

-	/* Otherwise, the X server has revoqued its root uid, 

-	   and thus cannot give up IO privileges any more */

-	   

-	return;

-}

-

-#endif /* USE_AMD64_IOPL */

-

-#ifdef USE_DEV_IO

-static int IoFd = -1;

-

-Bool

-xf86EnableIO()

-{

-	if (IoFd >= 0)

-		return TRUE;

-

-	if ((IoFd = open("/dev/io", O_RDWR)) == -1)

-	{

-		xf86Msg(X_WARNING,"xf86EnableIO: "

-				"Failed to open /dev/io for extended I/O");

-		return FALSE;

-	}

-	return TRUE;

-}

-

-void

-xf86DisableIO()

-{

-	if (IoFd < 0)

-		return;

-

-	close(IoFd);

-	IoFd = -1;

-	return;

-}

-

-#endif

-

-#ifdef __NetBSD__

-/***************************************************************************/

-/* Set TV output mode                                                      */

-/***************************************************************************/

-void

-xf86SetTVOut(int mode)

-{    

-    switch (xf86Info.consType)

-    {

-#ifdef PCCONS_SUPPORT

-	case PCCONS:{

-

-	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_TV_ON, &mode) < 0)

-	    {

-		xf86Msg(X_WARNING,

-		    "xf86SetTVOut: Could not set console to TV output, %s\n",

-		    strerror(errno));

-	    }

-	}

-	break;

-#endif /* PCCONS_SUPPORT */

-

-	default:

-	    FatalError("Xf86SetTVOut: Unsupported console");

-	    break; 

-    }

-    return;

-}

-

-void

-xf86SetRGBOut()

-{    

-    switch (xf86Info.consType)

-    {

-#ifdef PCCONS_SUPPORT

-	case PCCONS:{

-	    

-	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_TV_OFF, 0) < 0)

-	    {

-		xf86Msg(X_WARNING,

-		    "xf86SetTVOut: Could not set console to RGB output, %s\n",

-		    strerror(errno));

-	    }

-	}

-	break;

-#endif /* PCCONS_SUPPORT */

-

-	default:

-	    FatalError("Xf86SetTVOut: Unsupported console");

-	    break; 

-    }

-    return;

-}

-#endif

-

-#ifdef HAS_MTRR_SUPPORT

-/* memory range (MTRR) support for FreeBSD */

-

-/*

- * This code is experimental.  Some parts may be overkill, and other parts

- * may be incomplete.

- */

-

-/*

- * getAllRanges returns the full list of memory ranges with attributes set.

- */

-

-static struct mem_range_desc *

-getAllRanges(int *nmr)

-{

-	struct mem_range_desc *mrd;

-	struct mem_range_op mro;

-

-	/*

-	 * Find how many ranges there are.  If this fails, then the kernel

-	 * probably doesn't have MTRR support.

-	 */

-	mro.mo_arg[0] = 0;

-	if (ioctl(devMemFd, MEMRANGE_GET, &mro))

-		return NULL;

-	*nmr = mro.mo_arg[0];

-	mrd = xnfalloc(*nmr * sizeof(struct mem_range_desc));

-	mro.mo_arg[0] = *nmr;

-	mro.mo_desc = mrd;

-	if (ioctl(devMemFd, MEMRANGE_GET, &mro)) {

-		free(mrd);

-		return NULL;

-	}

-	return mrd;

-}

-

-/*

- * cleanMTRR removes any memory attribute that may be left by a previous

- * X server.  Normally there won't be any, but this takes care of the

- * case where a server crashed without being able finish cleaning up.

- */

-

-static Bool

-cleanMTRR()

-{

-	struct mem_range_desc *mrd;

-	struct mem_range_op mro;

-	int nmr, i;

-

-	/* This shouldn't happen */

-	if (devMemFd < 0)

-		return FALSE;

-

-	if (!(mrd = getAllRanges(&nmr)))

-		return FALSE;

-

-	for (i = 0; i < nmr; i++) {

-		if (strcmp(mrd[i].mr_owner, X_MTRR_ID) == 0 &&

-		    (mrd[i].mr_flags & MDF_ACTIVE)) {

-#ifdef DEBUG

-			ErrorF("Clean for (0x%lx,0x%lx)\n",

-				(unsigned long)mrd[i].mr_base,

-				(unsigned long)mrd[i].mr_len);

-#endif

-			if (mrd[i].mr_flags & MDF_FIXACTIVE) {

-				mro.mo_arg[0] = MEMRANGE_SET_UPDATE;

-				mrd[i].mr_flags = MDF_UNCACHEABLE;

-			} else {

-				mro.mo_arg[0] = MEMRANGE_SET_REMOVE;

-			}

-			mro.mo_desc = mrd + i;

-			ioctl(devMemFd, MEMRANGE_SET, &mro);

-		}

-	}

-#ifdef DEBUG

-	sleep(10);

-#endif

-	free(mrd);

-	return TRUE;

-}

-

-typedef struct x_RangeRec {

-	struct mem_range_desc	mrd;

-	Bool			wasWC;

-	struct x_RangeRec *	next;

-} RangeRec, *RangePtr;

-

-static void

-freeRangeList(RangePtr range)

-{

-	RangePtr rp;

-

-	while (range) {

-		rp = range;

-		range = rp->next;

-		free(rp);

-	}

-}

-

-static RangePtr

-dupRangeList(RangePtr list)

-{

-	RangePtr new = NULL, rp, p;

-

-	rp = list;

-	while (rp) {

-		p = xnfalloc(sizeof(RangeRec));

-		*p = *rp;

-		p->next = new;

-		new = p;

-		rp = rp->next;

-	}

-	return new;

-}

-

-static RangePtr

-sortRangeList(RangePtr list)

-{

-	RangePtr rp1, rp2, copy, sorted = NULL, minp, prev, minprev;

-	unsigned long minBase;

-

-	/* Sort by base address */

-	rp1 = copy = dupRangeList(list);

-	while (rp1) {

-		minBase = rp1->mrd.mr_base;

-		minp = rp1;

-		minprev = NULL;

-		prev = rp1;

-		rp2 = rp1->next;

-		while (rp2) {

-			if (rp2->mrd.mr_base < minBase) {

-				minBase = rp2->mrd.mr_base;

-				minp = rp2;

-				minprev = prev;

-			}

-			prev = rp2;

-			rp2 = rp2->next;

-		}

-		if (minprev) {

-			minprev->next = minp->next;

-			rp1 = copy;

-		} else {

-			rp1 = minp->next;

-		}

-		minp->next = sorted;

-		sorted = minp;

-	}

-	return sorted;

-}

-

-/*

- * findRanges returns a list of ranges that overlap the specified range.

- */

-

-static void

-findRanges(unsigned long base, unsigned long size, RangePtr *ucp, RangePtr *wcp)

-{

-	struct mem_range_desc *mrd;

-	int nmr, i;

-	RangePtr rp, *p;

-	

-	if (!(mrd = getAllRanges(&nmr)))

-		return;

-

-	for (i = 0; i < nmr; i++) {

-		if ((mrd[i].mr_flags & MDF_ACTIVE) &&

-		    mrd[i].mr_base < base + size &&

-		    mrd[i].mr_base + mrd[i].mr_len > base) {

-			if (mrd[i].mr_flags & MDF_WRITECOMBINE)

-				p = wcp;

-			else if (mrd[i].mr_flags & MDF_UNCACHEABLE)

-				p = ucp;

-			else

-				continue;

-			rp = xnfalloc(sizeof(RangeRec));

-			rp->mrd = mrd[i];

-			rp->next = *p;

-			*p = rp;

-		}

-	}

-	free(mrd);

-}

-

-/*

- * This checks if the existing overlapping ranges fully cover the requested

- * range.  Is this overkill?

- */

-

-static Bool

-fullCoverage(unsigned long base, unsigned long size, RangePtr overlap)

-{

-	RangePtr rp1, sorted = NULL;

-	unsigned long end;

-

-	sorted = sortRangeList(overlap);

-	/* Look for gaps */

-	rp1 = sorted;

-	end = base + size;

-	while (rp1) {

-		if (rp1->mrd.mr_base > base) {

-			freeRangeList(sorted);

-			return FALSE;

-		} else {

-			base = rp1->mrd.mr_base + rp1->mrd.mr_len;

-		}

-		if (base >= end) {

-			freeRangeList(sorted);

-			return TRUE;

-		}

-		rp1 = rp1->next;

-	}

-	freeRangeList(sorted);

-	return FALSE;

-}

-

-static pointer

-addWC(int screenNum, unsigned long base, unsigned long size, MessageType from)

-{

-	RangePtr uc = NULL, wc = NULL, retlist = NULL;

-	struct mem_range_desc mrd;

-	struct mem_range_op mro;

-

-	findRanges(base, size, &uc, &wc);

-

-	/* See of the full range is already WC */

-	if (!uc && fullCoverage(base, size, wc)) {

-		xf86DrvMsg(screenNum, from, 

-		   "Write-combining range (0x%lx,0x%lx) was already set\n",

-		    base, size);

-		return NULL;

-	}

-

-	/* Otherwise, try to add the new range */

-	mrd.mr_base = base;

-	mrd.mr_len = size;

-	strcpy(mrd.mr_owner, X_MTRR_ID);

-	mrd.mr_flags = MDF_WRITECOMBINE;

-	mro.mo_desc = &mrd;

-	mro.mo_arg[0] = MEMRANGE_SET_UPDATE;

-	if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {

-		xf86DrvMsg(screenNum, X_WARNING,

-			   "Failed to set write-combining range "

-			   "(0x%lx,0x%lx)\n", base, size);

-		return NULL;

-	} else {

-		xf86DrvMsg(screenNum, from,

-			   "Write-combining range (0x%lx,0x%lx)\n", base, size);

-		retlist = xnfalloc(sizeof(RangeRec));

-		retlist->mrd = mrd;

-		retlist->wasWC = FALSE;

-		retlist->next = NULL;

-		return retlist;

-	}

-}

-

-static pointer

-delWC(int screenNum, unsigned long base, unsigned long size, MessageType from)

-{

-	RangePtr uc = NULL, wc = NULL, retlist = NULL;

-	struct mem_range_desc mrd;

-	struct mem_range_op mro;

-

-	findRanges(base, size, &uc, &wc);

-

-	/*

-	 * See of the full range is already not WC, or if there is full

-	 * coverage from UC ranges.

-	 */

-	if (!wc || fullCoverage(base, size, uc)) {

-		xf86DrvMsg(screenNum, from, 

-		   "Write-combining range (0x%lx,0x%lx) was already clear\n",

-		    base, size);

-		return NULL;

-	}

-

-	/* Otherwise, try to add the new range */

-	mrd.mr_base = base;

-	mrd.mr_len = size;

-	strcpy(mrd.mr_owner, X_MTRR_ID);

-	mrd.mr_flags = MDF_UNCACHEABLE;

-	mro.mo_desc = &mrd;

-	mro.mo_arg[0] = MEMRANGE_SET_UPDATE;

-	if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {

-		xf86DrvMsg(screenNum, X_WARNING,

-			   "Failed to remove write-combining range "

-			   "(0x%lx,0x%lx)\n", base, size);

-		/* XXX Should then remove all of the overlapping WC ranges */

-		return NULL;

-	} else {

-		xf86DrvMsg(screenNum, from,

-			   "Removed Write-combining range (0x%lx,0x%lx)\n",

-			   base, size);

-		retlist = xnfalloc(sizeof(RangeRec));

-		retlist->mrd = mrd;

-		retlist->wasWC = TRUE;

-		retlist->next = NULL;

-		return retlist;

-	}

-}

-

-static pointer

-setWC(int screenNum, unsigned long base, unsigned long size, Bool enable,

-	MessageType from)

-{

-	if (enable)

-		return addWC(screenNum, base, size, from);

-	else

-		return delWC(screenNum, base, size, from);

-}

-

-static void

-undoWC(int screenNum, pointer list)

-{

-	RangePtr rp;

-	struct mem_range_op mro;

-	Bool failed;

-

-	rp = list;

-	while (rp) {

-#ifdef DEBUG

-		ErrorF("Undo for (0x%lx,0x%lx), %d\n",

-			(unsigned long)rp->mrd.mr_base,

-			(unsigned long)rp->mrd.mr_len, rp->wasWC);

-#endif

-		failed = FALSE;

-		if (rp->wasWC) {

-			mro.mo_arg[0] = MEMRANGE_SET_UPDATE;

-			rp->mrd.mr_flags = MDF_WRITECOMBINE;

-			strcpy(rp->mrd.mr_owner, "unknown");

-		} else {

-			mro.mo_arg[0] = MEMRANGE_SET_REMOVE;

-		}

-		mro.mo_desc = &rp->mrd;

-

-		if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {

-			if (!rp->wasWC) {

-				mro.mo_arg[0] = MEMRANGE_SET_UPDATE;

-				rp->mrd.mr_flags = MDF_UNCACHEABLE;

-				strcpy(rp->mrd.mr_owner, "unknown");

-				if (ioctl(devMemFd, MEMRANGE_SET, &mro))

-					failed = TRUE;

-			} else

-				failed = TRUE;

-		}

-		if (failed) {

-			xf86DrvMsg(screenNum, X_WARNING,

-				"Failed to restore MTRR range (0x%lx,0x%lx)\n",

-				(unsigned long)rp->mrd.mr_base,

-				(unsigned long)rp->mrd.mr_len);

-		}

-		rp = rp->next;

-	}

-}

-

-#endif /* HAS_MTRR_SUPPORT */

-

-

-#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)

-static pointer

-NetBSDsetWC(int screenNum, unsigned long base, unsigned long size, Bool enable,

-	    MessageType from)

-{

-	struct mtrr *mtrrp;

-	int n;

-

-	xf86DrvMsg(screenNum, X_WARNING,

-		   "%s MTRR %lx - %lx\n", enable ? "set" : "remove",

-		   base, (base + size));

-

-	mtrrp = xnfalloc(sizeof (struct mtrr));

-	mtrrp->base = base;

-	mtrrp->len = size;

-	mtrrp->type = MTRR_TYPE_WC;

-

-	/*

-	 * MTRR_PRIVATE will make this MTRR get reset automatically

-	 * if this process exits, so we have no need for an explicit

-	 * cleanup operation when starting a new server.

-	 */

-

-	if (enable)

-		mtrrp->flags = MTRR_VALID | MTRR_PRIVATE;

-	else

-		mtrrp->flags = 0;

-	n = 1;

-

-	if (i386_set_mtrr(mtrrp, &n) < 0) {

-		free(mtrrp);

-		return NULL;

-	}

-	return mtrrp;

-}

-

-static void

-NetBSDundoWC(int screenNum, pointer list)

-{

-	struct mtrr *mtrrp = (struct mtrr *)list;

-	int n;

-

-	if (mtrrp == NULL)

-		return;

-	n = 1;

-	mtrrp->flags &= ~MTRR_VALID;

-	i386_set_mtrr(mtrrp, &n);

-	free(mtrrp);

-}

-#endif

+/*
+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Rich Murphey and David Wexelblat 
+ * not be used in advertising or publicity pertaining to distribution of 
+ * the software without specific, written prior permission.  Rich Murphey and
+ * David Wexelblat make no representations about the suitability of this 
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ *
+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "xf86.h"
+#include "xf86Priv.h"
+
+#include <errno.h>
+#include <sys/mman.h>
+
+#ifdef HAS_MTRR_SUPPORT
+#ifndef __NetBSD__
+#include <sys/types.h>
+#include <sys/memrange.h>
+#else
+#include "memrange.h"
+#endif
+#define X_MTRR_ID "XFree86"
+#endif
+
+#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)
+#include <machine/mtrr.h>
+#include <machine/sysarch.h>
+#include <sys/queue.h>
+#ifdef __x86_64__
+#define i386_set_mtrr x86_64_set_mtrr
+#define i386_get_mtrr x86_64_get_mtrr
+#define i386_iopl x86_64_iopl
+#endif
+#endif
+
+#include "xf86_OSlib.h"
+#include "xf86OSpriv.h"
+
+#if defined(__NetBSD__) && !defined(MAP_FILE)
+#define MAP_FLAGS MAP_SHARED
+#else
+#define MAP_FLAGS (MAP_FILE | MAP_SHARED)
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((caddr_t)-1)
+#endif
+
+#ifdef __OpenBSD__
+#define SYSCTL_MSG "\tCheck that you have set 'machdep.allowaperture=1'\n"\
+		   "\tin /etc/sysctl.conf and reboot your machine\n" \
+		   "\trefer to xf86(4) for details"
+#define SYSCTL_MSG2 \
+		"Check that you have set 'machdep.allowaperture=2'\n" \
+		"\tin /etc/sysctl.conf and reboot your machine\n" \
+		"\trefer to xf86(4) for details"
+#endif
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+static Bool useDevMem = FALSE;
+static int  devMemFd = -1;
+
+#ifdef HAS_APERTURE_DRV
+#define DEV_APERTURE "/dev/xf86"
+#endif
+#define DEV_MEM "/dev/mem"
+
+static pointer mapVidMem(int, unsigned long, unsigned long, int);
+static void unmapVidMem(int, pointer, unsigned long);
+
+#ifdef HAS_MTRR_SUPPORT
+static pointer setWC(int, unsigned long, unsigned long, Bool, MessageType);
+static void undoWC(int, pointer);
+static Bool cleanMTRR(void);
+#endif
+#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)
+static pointer NetBSDsetWC(int, unsigned long, unsigned long, Bool,
+			   MessageType);
+static void NetBSDundoWC(int, pointer);
+#endif
+
+/*
+ * Check if /dev/mem can be mmap'd.  If it can't print a warning when
+ * "warn" is TRUE.
+ */
+static void
+checkDevMem(Bool warn)
+{
+	static Bool devMemChecked = FALSE;
+	int fd;
+	pointer base;
+
+	if (devMemChecked)
+	    return;
+	devMemChecked = TRUE;
+
+	if ((fd = open(DEV_MEM, O_RDWR)) >= 0)
+	{
+	    /* Try to map a page at the VGA address */
+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
+				 MAP_FLAGS, fd, (off_t)0xA0000);
+	
+	    if (base != MAP_FAILED)
+	    {
+		munmap((caddr_t)base, 4096);
+		devMemFd = fd;
+		useDevMem = TRUE;
+		return;
+	    } else {
+		/* This should not happen */
+		if (warn)
+		{
+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
+			    DEV_MEM, strerror(errno));
+		}
+		useDevMem = FALSE;
+		return;
+	    }
+	}
+#ifndef HAS_APERTURE_DRV
+	if (warn)
+	{ 
+	    xf86Msg(X_WARNING, "checkDevMem: failed to open %s (%s)\n",
+		    DEV_MEM, strerror(errno));
+	} 
+	useDevMem = FALSE;
+	return;
+#else
+	/* Failed to open /dev/mem, try the aperture driver */
+	if ((fd = open(DEV_APERTURE, O_RDWR)) >= 0)
+	{
+	    /* Try to map a page at the VGA address */
+	    base = mmap((caddr_t)0, 4096, PROT_READ | PROT_WRITE,
+			     MAP_FLAGS, fd, (off_t)0xA0000);
+	
+	    if (base != MAP_FAILED)
+	    {
+		munmap((caddr_t)base, 4096);
+		devMemFd = fd;
+		useDevMem = TRUE;
+		xf86Msg(X_INFO, "checkDevMem: using aperture driver %s\n",
+		        DEV_APERTURE);
+		return;
+	    } else {
+
+		if (warn)
+		{
+		    xf86Msg(X_WARNING, "checkDevMem: failed to mmap %s (%s)\n",
+			    DEV_APERTURE, strerror(errno));
+		}
+	    }
+	} else {
+	    if (warn)
+	    {
+#ifndef __OpenBSD__
+		xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
+			"\t(%s)\n", DEV_MEM, DEV_APERTURE, strerror(errno));
+#else /* __OpenBSD__ */
+		xf86Msg(X_WARNING, "checkDevMem: failed to open %s and %s\n"
+			"\t(%s)\n%s", DEV_MEM, DEV_APERTURE, strerror(errno),
+			SYSCTL_MSG);
+#endif /* __OpenBSD__ */
+	    }
+	}
+	
+	useDevMem = FALSE;
+	return;
+
+#endif
+}
+
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+	checkDevMem(TRUE);
+	pVidMem->linearSupported = useDevMem;
+	pVidMem->mapMem = mapVidMem;
+	pVidMem->unmapMem = unmapVidMem;
+
+#if HAVE_PCI_SYSTEM_INIT_DEV_MEM
+	if (useDevMem)
+		pci_system_init_dev_mem(devMemFd);
+#endif
+
+#ifdef HAS_MTRR_SUPPORT
+	if (useDevMem) {
+		if (cleanMTRR()) {
+			pVidMem->setWC = setWC;
+			pVidMem->undoWC = undoWC;
+		}
+	}
+#endif
+#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)
+	pVidMem->setWC = NetBSDsetWC;
+	pVidMem->undoWC = NetBSDundoWC;
+#endif
+	pVidMem->initialised = TRUE;
+}
+
+static pointer
+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+	pointer base;
+
+	checkDevMem(FALSE);
+
+	if (useDevMem)
+	{
+	    if (devMemFd < 0) 
+	    {
+		FatalError("xf86MapVidMem: failed to open %s (%s)",
+			   DEV_MEM, strerror(errno));
+	    }
+	    base = mmap((caddr_t)0, Size,
+			(flags & VIDMEM_READONLY) ?
+			 PROT_READ : (PROT_READ | PROT_WRITE),
+			MAP_FLAGS, devMemFd, (off_t)Base);
+	    if (base == MAP_FAILED)
+	    {
+		FatalError("%s: could not mmap %s [s=%lx,a=%lx] (%s)",
+			   "xf86MapVidMem", DEV_MEM, Size, Base, 
+			   strerror(errno));
+	    }
+	    return base;
+	}
+		
+	/* else, mmap /dev/vga */
+	if ((unsigned long)Base < 0xA0000 || (unsigned long)Base >= 0xC0000)
+	{
+		FatalError("%s: Address 0x%lx outside allowable range",
+			   "xf86MapVidMem", Base);
+	}
+	base = mmap(0, Size,
+		    (flags & VIDMEM_READONLY) ?
+		     PROT_READ : (PROT_READ | PROT_WRITE),
+		    MAP_FLAGS, xf86Info.consoleFd,
+		    (unsigned long)Base - 0xA0000
+	    );
+	if (base == MAP_FAILED)
+	{
+	    FatalError("xf86MapVidMem: Could not mmap /dev/vga (%s)",
+		       strerror(errno));
+	}
+	return base;
+}
+
+static void
+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+	munmap((caddr_t)Base, Size);
+}
+
+/*
+ * Read BIOS via mmap()ing DEV_MEM
+ */
+
+int
+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
+	     int Len)
+{
+	unsigned char *ptr;
+	int psize;
+	int mlen;
+
+	checkDevMem(TRUE);
+	if (devMemFd == -1) {
+	    return -1;
+	}
+
+	psize = getpagesize();
+	Offset += Base & (psize - 1);
+	Base &= ~(psize - 1);
+	mlen = (Offset + Len + psize - 1) & ~(psize - 1);
+	ptr = (unsigned char *)mmap((caddr_t)0, mlen, PROT_READ,
+					MAP_SHARED, devMemFd, (off_t)Base);
+	if ((long)ptr == -1)
+	{
+		xf86Msg(X_WARNING, 
+			"xf86ReadBIOS: %s mmap[s=%x,a=%lx,o=%lx] failed (%s)\n",
+			DEV_MEM, Len, Base, Offset, strerror(errno));
+#ifdef __OpenBSD__
+		if (Base < 0xa0000) {
+		    xf86Msg(X_WARNING, SYSCTL_MSG2);
+		} 
+#endif
+		return -1;
+	}
+#ifdef DEBUG
+	ErrorF("xf86ReadBIOS: BIOS at 0x%08x has signature 0x%04x\n",
+		Base, ptr[0] | (ptr[1] << 8));
+#endif
+	(void)memcpy(Buf, (void *)(ptr + Offset), Len);
+	(void)munmap((caddr_t)ptr, mlen);
+#ifdef DEBUG
+	xf86MsgVerb(X_INFO, 3, "xf86ReadBIOS(%x, %x, Buf, %x)"
+		"-> %02x %02x %02x %02x...\n",
+		Base, Offset, Len, Buf[0], Buf[1], Buf[2], Buf[3]);
+#endif
+	return Len;
+}
+
+#ifdef USE_I386_IOPL
+/***************************************************************************/
+/* I/O Permissions section                                                 */
+/***************************************************************************/
+
+static Bool ExtendedEnabled = FALSE;
+
+Bool
+xf86EnableIO()
+{
+	if (ExtendedEnabled)
+		return TRUE;
+
+	if (i386_iopl(TRUE) < 0)
+	{
+#ifndef __OpenBSD__
+		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O",
+			   "xf86EnableIO");
+#else
+		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O\n%s",
+			   "xf86EnableIO", SYSCTL_MSG);
+#endif
+		return FALSE;
+	}
+	ExtendedEnabled = TRUE;
+
+	return TRUE;
+}
+	
+void
+xf86DisableIO()
+{
+	if (!ExtendedEnabled)
+		return;
+
+	i386_iopl(FALSE);
+	ExtendedEnabled = FALSE;
+
+	return;
+}
+
+#endif /* USE_I386_IOPL */
+
+#ifdef USE_AMD64_IOPL
+/***************************************************************************/
+/* I/O Permissions section                                                 */
+/***************************************************************************/
+
+static Bool ExtendedEnabled = FALSE;
+
+Bool
+xf86EnableIO()
+{
+	if (ExtendedEnabled)
+		return TRUE;
+
+	if (amd64_iopl(TRUE) < 0)
+	{
+#ifndef __OpenBSD__
+		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O",
+			   "xf86EnableIO");
+#else
+		xf86Msg(X_WARNING,"%s: Failed to set IOPL for extended I/O\n%s",
+			   "xf86EnableIO", SYSCTL_MSG);
+#endif
+		return FALSE;
+	}
+	ExtendedEnabled = TRUE;
+
+	return TRUE;
+}
+	
+void
+xf86DisableIO()
+{
+	if (!ExtendedEnabled)
+		return;
+
+	if (amd64_iopl(FALSE) == 0) {
+		ExtendedEnabled = FALSE;
+	}
+	/* Otherwise, the X server has revoqued its root uid, 
+	   and thus cannot give up IO privileges any more */
+	   
+	return;
+}
+
+#endif /* USE_AMD64_IOPL */
+
+#ifdef USE_DEV_IO
+static int IoFd = -1;
+
+Bool
+xf86EnableIO()
+{
+	if (IoFd >= 0)
+		return TRUE;
+
+	if ((IoFd = open("/dev/io", O_RDWR)) == -1)
+	{
+		xf86Msg(X_WARNING,"xf86EnableIO: "
+				"Failed to open /dev/io for extended I/O");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+void
+xf86DisableIO()
+{
+	if (IoFd < 0)
+		return;
+
+	close(IoFd);
+	IoFd = -1;
+	return;
+}
+
+#endif
+
+#ifdef __NetBSD__
+/***************************************************************************/
+/* Set TV output mode                                                      */
+/***************************************************************************/
+void
+xf86SetTVOut(int mode)
+{    
+    switch (xf86Info.consType)
+    {
+#ifdef PCCONS_SUPPORT
+	case PCCONS:{
+
+	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_TV_ON, &mode) < 0)
+	    {
+		xf86Msg(X_WARNING,
+		    "xf86SetTVOut: Could not set console to TV output, %s\n",
+		    strerror(errno));
+	    }
+	}
+	break;
+#endif /* PCCONS_SUPPORT */
+
+	default:
+	    FatalError("Xf86SetTVOut: Unsupported console");
+	    break; 
+    }
+    return;
+}
+
+void
+xf86SetRGBOut()
+{    
+    switch (xf86Info.consType)
+    {
+#ifdef PCCONS_SUPPORT
+	case PCCONS:{
+	    
+	    if (ioctl (xf86Info.consoleFd, CONSOLE_X_TV_OFF, 0) < 0)
+	    {
+		xf86Msg(X_WARNING,
+		    "xf86SetTVOut: Could not set console to RGB output, %s\n",
+		    strerror(errno));
+	    }
+	}
+	break;
+#endif /* PCCONS_SUPPORT */
+
+	default:
+	    FatalError("Xf86SetTVOut: Unsupported console");
+	    break; 
+    }
+    return;
+}
+#endif
+
+#ifdef HAS_MTRR_SUPPORT
+/* memory range (MTRR) support for FreeBSD */
+
+/*
+ * This code is experimental.  Some parts may be overkill, and other parts
+ * may be incomplete.
+ */
+
+/*
+ * getAllRanges returns the full list of memory ranges with attributes set.
+ */
+
+static struct mem_range_desc *
+getAllRanges(int *nmr)
+{
+	struct mem_range_desc *mrd;
+	struct mem_range_op mro;
+
+	/*
+	 * Find how many ranges there are.  If this fails, then the kernel
+	 * probably doesn't have MTRR support.
+	 */
+	mro.mo_arg[0] = 0;
+	if (ioctl(devMemFd, MEMRANGE_GET, &mro))
+		return NULL;
+	*nmr = mro.mo_arg[0];
+	mrd = xnfalloc(*nmr * sizeof(struct mem_range_desc));
+	mro.mo_arg[0] = *nmr;
+	mro.mo_desc = mrd;
+	if (ioctl(devMemFd, MEMRANGE_GET, &mro)) {
+		free(mrd);
+		return NULL;
+	}
+	return mrd;
+}
+
+/*
+ * cleanMTRR removes any memory attribute that may be left by a previous
+ * X server.  Normally there won't be any, but this takes care of the
+ * case where a server crashed without being able finish cleaning up.
+ */
+
+static Bool
+cleanMTRR()
+{
+	struct mem_range_desc *mrd;
+	struct mem_range_op mro;
+	int nmr, i;
+
+	/* This shouldn't happen */
+	if (devMemFd < 0)
+		return FALSE;
+
+	if (!(mrd = getAllRanges(&nmr)))
+		return FALSE;
+
+	for (i = 0; i < nmr; i++) {
+		if (strcmp(mrd[i].mr_owner, X_MTRR_ID) == 0 &&
+		    (mrd[i].mr_flags & MDF_ACTIVE)) {
+#ifdef DEBUG
+			ErrorF("Clean for (0x%lx,0x%lx)\n",
+				(unsigned long)mrd[i].mr_base,
+				(unsigned long)mrd[i].mr_len);
+#endif
+			if (mrd[i].mr_flags & MDF_FIXACTIVE) {
+				mro.mo_arg[0] = MEMRANGE_SET_UPDATE;
+				mrd[i].mr_flags = MDF_UNCACHEABLE;
+			} else {
+				mro.mo_arg[0] = MEMRANGE_SET_REMOVE;
+			}
+			mro.mo_desc = mrd + i;
+			ioctl(devMemFd, MEMRANGE_SET, &mro);
+		}
+	}
+#ifdef DEBUG
+	sleep(10);
+#endif
+	free(mrd);
+	return TRUE;
+}
+
+typedef struct x_RangeRec {
+	struct mem_range_desc	mrd;
+	Bool			wasWC;
+	struct x_RangeRec *	next;
+} RangeRec, *RangePtr;
+
+static void
+freeRangeList(RangePtr range)
+{
+	RangePtr rp;
+
+	while (range) {
+		rp = range;
+		range = rp->next;
+		free(rp);
+	}
+}
+
+static RangePtr
+dupRangeList(RangePtr list)
+{
+	RangePtr new = NULL, rp, p;
+
+	rp = list;
+	while (rp) {
+		p = xnfalloc(sizeof(RangeRec));
+		*p = *rp;
+		p->next = new;
+		new = p;
+		rp = rp->next;
+	}
+	return new;
+}
+
+static RangePtr
+sortRangeList(RangePtr list)
+{
+	RangePtr rp1, rp2, copy, sorted = NULL, minp, prev, minprev;
+	unsigned long minBase;
+
+	/* Sort by base address */
+	rp1 = copy = dupRangeList(list);
+	while (rp1) {
+		minBase = rp1->mrd.mr_base;
+		minp = rp1;
+		minprev = NULL;
+		prev = rp1;
+		rp2 = rp1->next;
+		while (rp2) {
+			if (rp2->mrd.mr_base < minBase) {
+				minBase = rp2->mrd.mr_base;
+				minp = rp2;
+				minprev = prev;
+			}
+			prev = rp2;
+			rp2 = rp2->next;
+		}
+		if (minprev) {
+			minprev->next = minp->next;
+			rp1 = copy;
+		} else {
+			rp1 = minp->next;
+		}
+		minp->next = sorted;
+		sorted = minp;
+	}
+	return sorted;
+}
+
+/*
+ * findRanges returns a list of ranges that overlap the specified range.
+ */
+
+static void
+findRanges(unsigned long base, unsigned long size, RangePtr *ucp, RangePtr *wcp)
+{
+	struct mem_range_desc *mrd;
+	int nmr, i;
+	RangePtr rp, *p;
+	
+	if (!(mrd = getAllRanges(&nmr)))
+		return;
+
+	for (i = 0; i < nmr; i++) {
+		if ((mrd[i].mr_flags & MDF_ACTIVE) &&
+		    mrd[i].mr_base < base + size &&
+		    mrd[i].mr_base + mrd[i].mr_len > base) {
+			if (mrd[i].mr_flags & MDF_WRITECOMBINE)
+				p = wcp;
+			else if (mrd[i].mr_flags & MDF_UNCACHEABLE)
+				p = ucp;
+			else
+				continue;
+			rp = xnfalloc(sizeof(RangeRec));
+			rp->mrd = mrd[i];
+			rp->next = *p;
+			*p = rp;
+		}
+	}
+	free(mrd);
+}
+
+/*
+ * This checks if the existing overlapping ranges fully cover the requested
+ * range.  Is this overkill?
+ */
+
+static Bool
+fullCoverage(unsigned long base, unsigned long size, RangePtr overlap)
+{
+	RangePtr rp1, sorted = NULL;
+	unsigned long end;
+
+	sorted = sortRangeList(overlap);
+	/* Look for gaps */
+	rp1 = sorted;
+	end = base + size;
+	while (rp1) {
+		if (rp1->mrd.mr_base > base) {
+			freeRangeList(sorted);
+			return FALSE;
+		} else {
+			base = rp1->mrd.mr_base + rp1->mrd.mr_len;
+		}
+		if (base >= end) {
+			freeRangeList(sorted);
+			return TRUE;
+		}
+		rp1 = rp1->next;
+	}
+	freeRangeList(sorted);
+	return FALSE;
+}
+
+static pointer
+addWC(int screenNum, unsigned long base, unsigned long size, MessageType from)
+{
+	RangePtr uc = NULL, wc = NULL, retlist = NULL;
+	struct mem_range_desc mrd;
+	struct mem_range_op mro;
+
+	findRanges(base, size, &uc, &wc);
+
+	/* See of the full range is already WC */
+	if (!uc && fullCoverage(base, size, wc)) {
+		xf86DrvMsg(screenNum, from, 
+		   "Write-combining range (0x%lx,0x%lx) was already set\n",
+		    base, size);
+		return NULL;
+	}
+
+	/* Otherwise, try to add the new range */
+	mrd.mr_base = base;
+	mrd.mr_len = size;
+	strcpy(mrd.mr_owner, X_MTRR_ID);
+	mrd.mr_flags = MDF_WRITECOMBINE;
+	mro.mo_desc = &mrd;
+	mro.mo_arg[0] = MEMRANGE_SET_UPDATE;
+	if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {
+		xf86DrvMsg(screenNum, X_WARNING,
+			   "Failed to set write-combining range "
+			   "(0x%lx,0x%lx)\n", base, size);
+		return NULL;
+	} else {
+		xf86DrvMsg(screenNum, from,
+			   "Write-combining range (0x%lx,0x%lx)\n", base, size);
+		retlist = xnfalloc(sizeof(RangeRec));
+		retlist->mrd = mrd;
+		retlist->wasWC = FALSE;
+		retlist->next = NULL;
+		return retlist;
+	}
+}
+
+static pointer
+delWC(int screenNum, unsigned long base, unsigned long size, MessageType from)
+{
+	RangePtr uc = NULL, wc = NULL, retlist = NULL;
+	struct mem_range_desc mrd;
+	struct mem_range_op mro;
+
+	findRanges(base, size, &uc, &wc);
+
+	/*
+	 * See of the full range is already not WC, or if there is full
+	 * coverage from UC ranges.
+	 */
+	if (!wc || fullCoverage(base, size, uc)) {
+		xf86DrvMsg(screenNum, from, 
+		   "Write-combining range (0x%lx,0x%lx) was already clear\n",
+		    base, size);
+		return NULL;
+	}
+
+	/* Otherwise, try to add the new range */
+	mrd.mr_base = base;
+	mrd.mr_len = size;
+	strcpy(mrd.mr_owner, X_MTRR_ID);
+	mrd.mr_flags = MDF_UNCACHEABLE;
+	mro.mo_desc = &mrd;
+	mro.mo_arg[0] = MEMRANGE_SET_UPDATE;
+	if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {
+		xf86DrvMsg(screenNum, X_WARNING,
+			   "Failed to remove write-combining range "
+			   "(0x%lx,0x%lx)\n", base, size);
+		/* XXX Should then remove all of the overlapping WC ranges */
+		return NULL;
+	} else {
+		xf86DrvMsg(screenNum, from,
+			   "Removed Write-combining range (0x%lx,0x%lx)\n",
+			   base, size);
+		retlist = xnfalloc(sizeof(RangeRec));
+		retlist->mrd = mrd;
+		retlist->wasWC = TRUE;
+		retlist->next = NULL;
+		return retlist;
+	}
+}
+
+static pointer
+setWC(int screenNum, unsigned long base, unsigned long size, Bool enable,
+	MessageType from)
+{
+	if (enable)
+		return addWC(screenNum, base, size, from);
+	else
+		return delWC(screenNum, base, size, from);
+}
+
+static void
+undoWC(int screenNum, pointer list)
+{
+	RangePtr rp;
+	struct mem_range_op mro;
+	Bool failed;
+
+	rp = list;
+	while (rp) {
+#ifdef DEBUG
+		ErrorF("Undo for (0x%lx,0x%lx), %d\n",
+			(unsigned long)rp->mrd.mr_base,
+			(unsigned long)rp->mrd.mr_len, rp->wasWC);
+#endif
+		failed = FALSE;
+		if (rp->wasWC) {
+			mro.mo_arg[0] = MEMRANGE_SET_UPDATE;
+			rp->mrd.mr_flags = MDF_WRITECOMBINE;
+			strcpy(rp->mrd.mr_owner, "unknown");
+		} else {
+			mro.mo_arg[0] = MEMRANGE_SET_REMOVE;
+		}
+		mro.mo_desc = &rp->mrd;
+
+		if (ioctl(devMemFd, MEMRANGE_SET, &mro)) {
+			if (!rp->wasWC) {
+				mro.mo_arg[0] = MEMRANGE_SET_UPDATE;
+				rp->mrd.mr_flags = MDF_UNCACHEABLE;
+				strcpy(rp->mrd.mr_owner, "unknown");
+				if (ioctl(devMemFd, MEMRANGE_SET, &mro))
+					failed = TRUE;
+			} else
+				failed = TRUE;
+		}
+		if (failed) {
+			xf86DrvMsg(screenNum, X_WARNING,
+				"Failed to restore MTRR range (0x%lx,0x%lx)\n",
+				(unsigned long)rp->mrd.mr_base,
+				(unsigned long)rp->mrd.mr_len);
+		}
+		rp = rp->next;
+	}
+}
+
+#endif /* HAS_MTRR_SUPPORT */
+
+
+#if defined(HAS_MTRR_BUILTIN) && defined(__NetBSD__)
+static pointer
+NetBSDsetWC(int screenNum, unsigned long base, unsigned long size, Bool enable,
+	    MessageType from)
+{
+	struct mtrr *mtrrp;
+	int n;
+
+	xf86DrvMsg(screenNum, X_WARNING,
+		   "%s MTRR %lx - %lx\n", enable ? "set" : "remove",
+		   base, (base + size));
+
+	mtrrp = xnfalloc(sizeof (struct mtrr));
+	mtrrp->base = base;
+	mtrrp->len = size;
+	mtrrp->type = MTRR_TYPE_WC;
+
+	/*
+	 * MTRR_PRIVATE will make this MTRR get reset automatically
+	 * if this process exits, so we have no need for an explicit
+	 * cleanup operation when starting a new server.
+	 */
+
+	if (enable)
+		mtrrp->flags = MTRR_VALID | MTRR_PRIVATE;
+	else
+		mtrrp->flags = 0;
+	n = 1;
+
+	if (i386_set_mtrr(mtrrp, &n) < 0) {
+		free(mtrrp);
+		return NULL;
+	}
+	return mtrrp;
+}
+
+static void
+NetBSDundoWC(int screenNum, pointer list)
+{
+	struct mtrr *mtrrp = (struct mtrr *)list;
+	int n;
+
+	if (mtrrp == NULL)
+		return;
+	n = 1;
+	mtrrp->flags &= ~MTRR_VALID;
+	i386_set_mtrr(mtrrp, &n);
+	free(mtrrp);
+}
+#endif
diff --git a/xorg-server/hw/xfree86/os-support/bsd/ppc_video.c b/xorg-server/hw/xfree86/os-support/bsd/ppc_video.c
index 7e3fcdb2c..aeaf18305 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/ppc_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/ppc_video.c
@@ -73,7 +73,7 @@ volatile unsigned char *ioBase = MAP_FAILED;
 static pointer
 ppcMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
 {
-	int fd = xf86Info.screenFd;
+	int fd = xf86Info.consoleFd;
 	pointer base;
 #ifdef DEBUG
 	xf86MsgVerb(X_INFO, 3, "mapVidMem %lx, %lx, fd = %d", 
@@ -125,7 +125,7 @@ xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
 
 Bool xf86EnableIO()
 {
-        int fd = xf86Info.screenFd;
+        int fd = xf86Info.consoleFd;
 
         xf86MsgVerb(X_WARNING, 3, "xf86EnableIO %d\n", fd);
         if (ioBase == MAP_FAILED)
diff --git a/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c b/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
index 1dcd77711..a2a30c9d7 100644
--- a/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
+++ b/xorg-server/hw/xfree86/os-support/bsd/sparc64_video.c
@@ -1,91 +1,91 @@
-/*

- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

- * Copyright 1993 by David Wexelblat <dwex@goblin.org>

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the names of Rich Murphey and David Wexelblat 

- * not be used in advertising or publicity pertaining to distribution of 

- * the software without specific, written prior permission.  Rich Murphey and

- * David Wexelblat make no representations about the suitability of this 

- * software for any purpose.  It is provided "as is" without express or 

- * implied warranty.

- *

- * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 

- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 

- * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 

- * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 

- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 

- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- *

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <X11/X.h>

-#include "xf86.h"

-#include "xf86Priv.h"

-

-#include "xf86_OSlib.h"

-#include "xf86OSpriv.h"

-

-#ifndef MAP_FAILED

-#define MAP_FAILED ((caddr_t)-1)

-#endif

-

-/***************************************************************************/

-/* Video Memory Mapping section                                            */

-/***************************************************************************/

-

-static pointer sparc64MapVidMem(int, unsigned long, unsigned long, int);

-static void sparc64UnmapVidMem(int, pointer, unsigned long);

-

-void

-xf86OSInitVidMem(VidMemInfoPtr pVidMem)

-{

-	pVidMem->linearSupported = TRUE;

-	pVidMem->mapMem = sparc64MapVidMem;

-	pVidMem->unmapMem = sparc64UnmapVidMem;

-	pVidMem->initialised = TRUE;

-}

-

-static pointer

-sparc64MapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, 

-		 int flags)

-{

-	int fd = xf86Info.screenFd;

-	pointer base;

-

-#ifdef DEBUG

-	xf86MsgVerb(X_INFO, 3, "mapVidMem %lx, %lx, fd = %d", 

-		    Base, Size, fd);

-#endif

-

-	base = mmap(0, Size,

-		    (flags & VIDMEM_READONLY) ?

-		     PROT_READ : (PROT_READ | PROT_WRITE),

-		    MAP_SHARED, fd, Base);

-	if (base == MAP_FAILED)

-		FatalError("%s: could not mmap screen [s=%x,a=%x] (%s)",

-			   "xf86MapVidMem", Size, Base, strerror(errno));

-	return base;

-}

-

-static void

-sparc64UnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)

-{

-	munmap(Base, Size);

-}

-

-int

-xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,

-	     int Len)

-{

-

-	return 0;

-}

+/*
+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Rich Murphey and David Wexelblat 
+ * not be used in advertising or publicity pertaining to distribution of 
+ * the software without specific, written prior permission.  Rich Murphey and
+ * David Wexelblat make no representations about the suitability of this 
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ *
+ * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+ * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "xf86.h"
+#include "xf86Priv.h"
+
+#include "xf86_OSlib.h"
+#include "xf86OSpriv.h"
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((caddr_t)-1)
+#endif
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+static pointer sparc64MapVidMem(int, unsigned long, unsigned long, int);
+static void sparc64UnmapVidMem(int, pointer, unsigned long);
+
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+	pVidMem->linearSupported = TRUE;
+	pVidMem->mapMem = sparc64MapVidMem;
+	pVidMem->unmapMem = sparc64UnmapVidMem;
+	pVidMem->initialised = TRUE;
+}
+
+static pointer
+sparc64MapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, 
+		 int flags)
+{
+	int fd = xf86Info.consoleFd;
+	pointer base;
+
+#ifdef DEBUG
+	xf86MsgVerb(X_INFO, 3, "mapVidMem %lx, %lx, fd = %d", 
+		    Base, Size, fd);
+#endif
+
+	base = mmap(0, Size,
+		    (flags & VIDMEM_READONLY) ?
+		     PROT_READ : (PROT_READ | PROT_WRITE),
+		    MAP_SHARED, fd, Base);
+	if (base == MAP_FAILED)
+		FatalError("%s: could not mmap screen [s=%x,a=%x] (%s)",
+			   "xf86MapVidMem", Size, Base, strerror(errno));
+	return base;
+}
+
+static void
+sparc64UnmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+	munmap(Base, Size);
+}
+
+int
+xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
+	     int Len)
+{
+
+	return 0;
+}
diff --git a/xorg-server/hw/xfree86/os-support/xf86_OSlib.h b/xorg-server/hw/xfree86/os-support/xf86_OSlib.h
index 6374ccab3..1d5906084 100644
--- a/xorg-server/hw/xfree86/os-support/xf86_OSlib.h
+++ b/xorg-server/hw/xfree86/os-support/xf86_OSlib.h
@@ -1,414 +1,394 @@
-/*

- * Copyright 1990, 1991 by Thomas Roell, Dinkelscherben, Germany

- * Copyright 1992 by David Dawes <dawes@XFree86.org>

- * Copyright 1992 by Jim Tsillas <jtsilla@damon.ccs.northeastern.edu>

- * Copyright 1992 by Rich Murphey <Rich@Rice.edu>

- * Copyright 1992 by Robert Baron <Robert.Baron@ernst.mach.cs.cmu.edu>

- * Copyright 1992 by Orest Zborowski <obz@eskimo.com>

- * Copyright 1993 by Vrije Universiteit, The Netherlands

- * Copyright 1993 by David Wexelblat <dwex@XFree86.org>

- * Copyright 1994, 1996 by Holger Veit <Holger.Veit@gmd.de>

- * Copyright 1997 by Takis Psarogiannakopoulos <takis@dpmms.cam.ac.uk>

- * Copyright 1994-2003 by The XFree86 Project, Inc

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the names of the above listed copyright holders 

- * not be used in advertising or publicity pertaining to distribution of 

- * the software without specific, written prior permission.  The above listed

- * copyright holders make no representations about the suitability of this 

- * software for any purpose.  It is provided "as is" without express or 

- * implied warranty.

- *

- * THE ABOVE LISTED COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD 

- * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 

- * AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDERS BE 

- * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 

- * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER 

- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 

- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- *

- */

-

-/*

- * The ARM32 code here carries the following copyright:

- *

- * Copyright 1997

- * Digital Equipment Corporation. All rights reserved.

- * This software is furnished under license and may be used and copied only in 

- * accordance with the following terms and conditions.  Subject to these

- * conditions, you may download, copy, install, use, modify and distribute

- * this software in source and/or binary form. No title or ownership is

- * transferred hereby.

- *

- * 1) Any source code used, modified or distributed must reproduce and retain

- *    this copyright notice and list of conditions as they appear in the

- *    source file.

- *

- * 2) No right is granted to use any trade name, trademark, or logo of Digital 

- *    Equipment Corporation. Neither the "Digital Equipment Corporation"

- *    name nor any trademark or logo of Digital Equipment Corporation may be

- *    used to endorse or promote products derived from this software without

- *    the prior written permission of Digital Equipment Corporation.

- *

- * 3) This software is provided "AS-IS" and any express or implied warranties,

- *    including but not limited to, any implied warranties of merchantability,

- *    fitness for a particular purpose, or non-infringement are disclaimed.

- *    In no event shall DIGITAL be liable for any damages whatsoever, and in

- *    particular, DIGITAL shall not be liable for special, indirect,

- *    consequential, or incidental damages or damages for lost profits, loss

- *    of revenue or loss of use, whether such damages arise in contract, 

- *    negligence, tort, under statute, in equity, at law or otherwise, even

- *    if advised of the possibility of such damage. 

- *

- */

-

-/*

- * This is private, and should not be included by any drivers.  Drivers

- * may include xf86_OSproc.h to get prototypes for public interfaces.

- */

-

-#ifndef _XF86_OSLIB_H

-#define _XF86_OSLIB_H

-

-#include <X11/Xos.h>

-#include <X11/Xfuncproto.h>

-

-#include <stdio.h>

-#include <ctype.h>

-#include <stddef.h>

-

-/**************************************************************************/

-/* SYSV386 (SVR3, SVR4), including Solaris                                */

-/**************************************************************************/

-#if (defined(SYSV) || defined(SVR4)) && \

-    (defined(sun) || defined(__i386__))

-# include <sys/ioctl.h>

-# include <signal.h>

-# include <termio.h>

-# include <sys/stat.h>

-# include <sys/types.h>

-

-

-# include <errno.h>

-

-# if defined(_NEED_SYSI86)

-#  if !(defined (sun) && defined (SVR4))

-#    include <sys/immu.h>

-#    include <sys/region.h>

-#  endif

-#  include <sys/proc.h>

-#  include <sys/tss.h>

-#  include <sys/sysi86.h>

-#  if defined(SVR4) && !defined(sun)

-#   include <sys/seg.h>

-#  endif /* SVR4 && !sun */

-/* V86SC_IOPL was moved to <sys/sysi86.h> on Solaris 7 and later */

-#  if !defined(V86SC_IOPL)			/* Solaris 7 or later? */

-#   include <sys/v86.h>				/* Nope */

-#  endif

-#  if defined(sun) && (defined (__i386__) || defined(__i386) || defined(__x86))  && defined (SVR4)

-#    include <sys/psw.h>

-#  endif

-# endif /* _NEED_SYSI86 */

-

-# if defined(HAS_SVR3_MMAPDRV)

-#  include <sys/sysmacros.h>

-#  if !defined(_NEED_SYSI86)

-#   include <sys/immu.h>

-#   include <sys/region.h>

-#  endif

-#  include <sys/mmap.h>		/* MMAP driver header */

-# endif

-

-# if !defined(sun) || defined(HAVE_SYS_VT_H)

-#  define HAS_USL_VTS

-# endif

-# if !defined(sun)

-#  include <sys/emap.h>

-# endif

-# if   defined(HAS_USL_VTS)

-#  if !defined(sun)

-#   include <sys/at_ansi.h>

-#  endif

-#  include <sys/kd.h>

-#  include <sys/vt.h>

-# endif

-

-# if defined(sun)

-#  include <sys/fbio.h>

-#  include <sys/kbd.h> 

-#  include <sys/kbio.h>

-

-/* undefine symbols from <sys/kbd.h> we don't need that conflict with enum

-   definitions in parser/xf86tokens.h */

-#  undef STRING

-#  undef LEFTALT

-#  undef RIGHTALT

-

-#  define LED_CAP LED_CAPS_LOCK

-#  define LED_NUM LED_NUM_LOCK

-#  define LED_SCR LED_SCROLL_LOCK

-#  define LED_COMP LED_COMPOSE

-# endif /* sun */

-

-# if !defined(VT_ACKACQ)

-#  define VT_ACKACQ 2

-# endif /* !VT_ACKACQ */

-

-

-# if defined(SVR4) 

-#  include <sys/mman.h>

-#  if !(defined(sun) && defined (SVR4))

-#    define DEV_MEM "/dev/pmem"

-#  endif

-#  define CLEARDTR_SUPPORT

-#  define POSIX_TTY

-# endif /* SVR4 */

-

-

-# if defined(sun) && defined(HAS_USL_VTS)

-#  define USE_VT_SYSREQ

-# endif

-

-#endif /* (SYSV || SVR4) */

-

-/**************************************************************************/

-/* Linux or Glibc-based system                                            */

-/**************************************************************************/

-#if defined(__linux__) || defined(__GLIBC__)

-# include <sys/ioctl.h>

-# include <signal.h>

-# include <stdlib.h>

-# include <sys/types.h>

-# include <assert.h>

-

-# ifdef __linux__

-#  include <termio.h>

-# else /* __GLIBC__ */

-#  include <termios.h>

-# endif

-# ifdef __sparc__

-#  include <sys/param.h>

-# endif

-

-# include <errno.h>

-

-# include <sys/stat.h>

-

-# include <sys/mman.h>

-# ifdef __linux__

-#  define HAS_USL_VTS

-#  include <sys/kd.h>

-#  include <sys/vt.h>

-#  define LDGMAP GIO_SCRNMAP

-#  define LDSMAP PIO_SCRNMAP

-#  define LDNMAP LDSMAP

-#  define CLEARDTR_SUPPORT

-#  define USE_VT_SYSREQ

-# endif

-

-# define POSIX_TTY

-

-#endif /* __linux__ || __GLIBC__ */

-

-/**************************************************************************/

-/* 386BSD and derivatives,  BSD/386                                       */

-/**************************************************************************/

-

-#if defined(__386BSD__) && (defined(__FreeBSD__) || defined(__NetBSD__))

-# undef __386BSD__

-#endif

-

-#ifdef CSRG_BASED

-# include <sys/ioctl.h>

-# include <signal.h>

-

-# include <termios.h>

-# define termio termios

-# define POSIX_TTY

-

-# include <errno.h>

-

-# include <sys/types.h>

-# include <sys/mman.h>

-# include <sys/stat.h>

-

-# if defined(__bsdi__)

-#  include <sys/param.h>

-# if (_BSDI_VERSION < 199510)

-#  include <i386/isa/vgaioctl.h>

-# endif

-# endif /* __bsdi__ */

-

-#endif /* CSRG_BASED */

-

-/**************************************************************************/

-/* Kernel of *BSD                                                         */

-/**************************************************************************/

-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \

- defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)

-

-# include <sys/param.h>

-# if defined(__FreeBSD_version) && !defined(__FreeBSD_kernel_version)

-#  define __FreeBSD_kernel_version __FreeBSD_version

-# endif

-

-# if !defined(LINKKIT)

-  /* Don't need this stuff for the Link Kit */

-#  if defined(__bsdi__)

-#   include <i386/isa/pcconsioctl.h>

-#   define CONSOLE_X_MODE_ON PCCONIOCRAW

-#   define CONSOLE_X_MODE_OFF PCCONIOCCOOK

-#   define CONSOLE_X_BELL PCCONIOCBEEP

-#  else /* __bsdi__ */

-#   ifdef SYSCONS_SUPPORT

-#    define COMPAT_SYSCONS

-#    if defined(__NetBSD__) || defined(__OpenBSD__)

-#     include <machine/console.h>

-#    else

-#     if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

-#        if defined(__DragonFly__)  || (__FreeBSD_kernel_version >= 410000)

-#          include <sys/consio.h>

-#          include <sys/kbio.h>

-#        else

-#          include <machine/console.h>

-#        endif /* FreeBSD 4.1 RELEASE or lator */

-#     else

-#      include <sys/console.h>

-#     endif

-#    endif

-#   endif /* SYSCONS_SUPPORT */

-#   if defined(PCVT_SUPPORT)

-#    if !defined(SYSCONS_SUPPORT)

-      /* no syscons, so include pcvt specific header file */

-#     if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

-#      include <machine/pcvt_ioctl.h>

-#     else

-#      if defined(__NetBSD__) || defined(__OpenBSD__)

-#       if !defined(WSCONS_SUPPORT)

-#        include <machine/pcvt_ioctl.h>

-#       endif /* WSCONS_SUPPORT */

-#      else

-#       include <sys/pcvt_ioctl.h>

-#      endif /* __NetBSD__ */

-#     endif /* __FreeBSD_kernel__ || __OpenBSD__ */

-#    else /* pcvt and syscons: hard-code the ID magic */

-#     define VGAPCVTID _IOWR('V',113, struct pcvtid)

-      struct pcvtid {

-	char name[16];

-	int rmajor, rminor;

-      };

-#    endif /* PCVT_SUPPORT && SYSCONS_SUPPORT */

-#   endif /* PCVT_SUPPORT */

-#   ifdef WSCONS_SUPPORT

-#    include <dev/wscons/wsconsio.h>

-#    include <dev/wscons/wsdisplay_usl_io.h>

-#   endif /* WSCONS_SUPPORT */

-#   if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

-#    if defined(__FreeBSD_kernel_version) && (__FreeBSD_kernel_version >= 500013)

-#     include <sys/mouse.h>

-#    else

-#     undef MOUSE_GETINFO

-#     include <machine/mouse.h>

-#    endif

-#   endif

-    /* Include these definitions in case ioctl_pc.h didn't get included */

-#   ifndef CONSOLE_X_MODE_ON

-#    define CONSOLE_X_MODE_ON _IO('t',121)

-#   endif

-#   ifndef CONSOLE_X_MODE_OFF

-#    define CONSOLE_X_MODE_OFF _IO('t',122)

-#   endif

-#   ifndef CONSOLE_X_BELL

-#    define CONSOLE_X_BELL _IOW('t',123,int[2])

-#   endif

-#   ifndef CONSOLE_X_TV_ON

-#    define CONSOLE_X_TV_ON _IOW('t',155,int)

-#    define XMODE_RGB   0

-#    define XMODE_NTSC  1

-#    define XMODE_PAL   2

-#    define XMODE_SECAM 3

-#   endif

-#   ifndef CONSOLE_X_TV_OFF

-#    define CONSOLE_X_TV_OFF _IO('t',156)

-#   endif

-#ifndef CONSOLE_GET_LINEAR_INFO

-#    define CONSOLE_GET_LINEAR_INFO         _IOR('t',157,struct map_info)

-#endif

-#ifndef CONSOLE_GET_IO_INFO 

-#    define CONSOLE_GET_IO_INFO             _IOR('t',158,struct map_info)

-#endif

-#ifndef CONSOLE_GET_MEM_INFO 

-#    define CONSOLE_GET_MEM_INFO            _IOR('t',159,struct map_info)

-#endif

-#  endif /* __bsdi__ */

-# endif /* !LINKKIT */

-

-#if defined(USE_I386_IOPL) || defined(USE_AMD64_IOPL)

-#include <machine/sysarch.h>

-#endif

-

-# define CLEARDTR_SUPPORT

-

-# if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)

-#  define USE_VT_SYSREQ

-# endif

-

-#endif

-/* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ || __bsdi__ */

-

-/**************************************************************************/

-/* IRIX                                                                   */

-/**************************************************************************/

-

-/**************************************************************************/

-/* Generic                                                                */

-/**************************************************************************/

-

-#include <sys/wait.h>	/* May need to adjust this for other OSs */

-

-/* For PATH_MAX */

-#include "misc.h"

-

-/* 

- * Hack originally for ISC 2.2 POSIX headers, but may apply elsewhere,

- * and it's safe, so just do it.

- */

-#if !defined(O_NDELAY) && defined(O_NONBLOCK)

-# define O_NDELAY O_NONBLOCK

-#endif /* !O_NDELAY && O_NONBLOCK */

-

-#if !defined(MAXHOSTNAMELEN)

-# define MAXHOSTNAMELEN 32

-#endif /* !MAXHOSTNAMELEN */

-

-#if defined(_POSIX_SOURCE)

-# include <limits.h>

-#else

-# define _POSIX_SOURCE

-# include <limits.h>

-# undef _POSIX_SOURCE

-#endif /* _POSIX_SOURCE */

-

-

-#ifndef DEV_MEM

-#define DEV_MEM "/dev/mem"

-#endif

-

-#ifndef VT_SYSREQ_DEFAULT

-#define VT_SYSREQ_DEFAULT FALSE

-#endif

-

-#define SYSCALL(call) while(((call) == -1) && (errno == EINTR))

-

-#define XF86_OS_PRIVS

-#include "xf86_OSproc.h"

-

-#ifndef NO_COMPILER_H

-#include "compiler.h"

-#endif

-

-#endif /* _XF86_OSLIB_H */

+/*
+ * Copyright 1990, 1991 by Thomas Roell, Dinkelscherben, Germany
+ * Copyright 1992 by David Dawes <dawes@XFree86.org>
+ * Copyright 1992 by Jim Tsillas <jtsilla@damon.ccs.northeastern.edu>
+ * Copyright 1992 by Rich Murphey <Rich@Rice.edu>
+ * Copyright 1992 by Robert Baron <Robert.Baron@ernst.mach.cs.cmu.edu>
+ * Copyright 1992 by Orest Zborowski <obz@eskimo.com>
+ * Copyright 1993 by Vrije Universiteit, The Netherlands
+ * Copyright 1993 by David Wexelblat <dwex@XFree86.org>
+ * Copyright 1994, 1996 by Holger Veit <Holger.Veit@gmd.de>
+ * Copyright 1997 by Takis Psarogiannakopoulos <takis@dpmms.cam.ac.uk>
+ * Copyright 1994-2003 by The XFree86 Project, Inc
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of the above listed copyright holders 
+ * not be used in advertising or publicity pertaining to distribution of 
+ * the software without specific, written prior permission.  The above listed
+ * copyright holders make no representations about the suitability of this 
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ *
+ * THE ABOVE LISTED COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD 
+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDERS BE 
+ * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
+ * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER 
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+/*
+ * The ARM32 code here carries the following copyright:
+ *
+ * Copyright 1997
+ * Digital Equipment Corporation. All rights reserved.
+ * This software is furnished under license and may be used and copied only in 
+ * accordance with the following terms and conditions.  Subject to these
+ * conditions, you may download, copy, install, use, modify and distribute
+ * this software in source and/or binary form. No title or ownership is
+ * transferred hereby.
+ *
+ * 1) Any source code used, modified or distributed must reproduce and retain
+ *    this copyright notice and list of conditions as they appear in the
+ *    source file.
+ *
+ * 2) No right is granted to use any trade name, trademark, or logo of Digital 
+ *    Equipment Corporation. Neither the "Digital Equipment Corporation"
+ *    name nor any trademark or logo of Digital Equipment Corporation may be
+ *    used to endorse or promote products derived from this software without
+ *    the prior written permission of Digital Equipment Corporation.
+ *
+ * 3) This software is provided "AS-IS" and any express or implied warranties,
+ *    including but not limited to, any implied warranties of merchantability,
+ *    fitness for a particular purpose, or non-infringement are disclaimed.
+ *    In no event shall DIGITAL be liable for any damages whatsoever, and in
+ *    particular, DIGITAL shall not be liable for special, indirect,
+ *    consequential, or incidental damages or damages for lost profits, loss
+ *    of revenue or loss of use, whether such damages arise in contract, 
+ *    negligence, tort, under statute, in equity, at law or otherwise, even
+ *    if advised of the possibility of such damage. 
+ *
+ */
+
+/*
+ * This is private, and should not be included by any drivers.  Drivers
+ * may include xf86_OSproc.h to get prototypes for public interfaces.
+ */
+
+#ifndef _XF86_OSLIB_H
+#define _XF86_OSLIB_H
+
+#include <X11/Xos.h>
+#include <X11/Xfuncproto.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <stddef.h>
+
+/**************************************************************************/
+/* SYSV386 (SVR3, SVR4), including Solaris                                */
+/**************************************************************************/
+#if (defined(SYSV) || defined(SVR4)) && \
+    (defined(sun) || defined(__i386__))
+# include <sys/ioctl.h>
+# include <signal.h>
+# include <termio.h>
+# include <sys/stat.h>
+# include <sys/types.h>
+
+
+# include <errno.h>
+
+# if defined(_NEED_SYSI86)
+#  if !(defined (sun) && defined (SVR4))
+#    include <sys/immu.h>
+#    include <sys/region.h>
+#  endif
+#  include <sys/proc.h>
+#  include <sys/tss.h>
+#  include <sys/sysi86.h>
+#  if defined(SVR4) && !defined(sun)
+#   include <sys/seg.h>
+#  endif /* SVR4 && !sun */
+/* V86SC_IOPL was moved to <sys/sysi86.h> on Solaris 7 and later */
+#  if !defined(V86SC_IOPL)			/* Solaris 7 or later? */
+#   include <sys/v86.h>				/* Nope */
+#  endif
+#  if defined(sun) && (defined (__i386__) || defined(__i386) || defined(__x86))  && defined (SVR4)
+#    include <sys/psw.h>
+#  endif
+# endif /* _NEED_SYSI86 */
+
+# if defined(HAS_SVR3_MMAPDRV)
+#  include <sys/sysmacros.h>
+#  if !defined(_NEED_SYSI86)
+#   include <sys/immu.h>
+#   include <sys/region.h>
+#  endif
+#  include <sys/mmap.h>		/* MMAP driver header */
+# endif
+
+# if !defined(sun) || defined(HAVE_SYS_VT_H)
+#  define HAS_USL_VTS
+# endif
+# if !defined(sun)
+#  include <sys/emap.h>
+# endif
+# if   defined(HAS_USL_VTS)
+#  if !defined(sun)
+#   include <sys/at_ansi.h>
+#  endif
+#  include <sys/kd.h>
+#  include <sys/vt.h>
+# endif
+
+# if defined(sun)
+#  include <sys/fbio.h>
+#  include <sys/kbd.h> 
+#  include <sys/kbio.h>
+
+/* undefine symbols from <sys/kbd.h> we don't need that conflict with enum
+   definitions in parser/xf86tokens.h */
+#  undef STRING
+#  undef LEFTALT
+#  undef RIGHTALT
+
+#  define LED_CAP LED_CAPS_LOCK
+#  define LED_NUM LED_NUM_LOCK
+#  define LED_SCR LED_SCROLL_LOCK
+#  define LED_COMP LED_COMPOSE
+# endif /* sun */
+
+# if !defined(VT_ACKACQ)
+#  define VT_ACKACQ 2
+# endif /* !VT_ACKACQ */
+
+
+# if defined(SVR4) 
+#  include <sys/mman.h>
+#  if !(defined(sun) && defined (SVR4))
+#    define DEV_MEM "/dev/pmem"
+#  endif
+#  define CLEARDTR_SUPPORT
+#  define POSIX_TTY
+# endif /* SVR4 */
+
+#endif /* (SYSV || SVR4) */
+
+/**************************************************************************/
+/* Linux or Glibc-based system                                            */
+/**************************************************************************/
+#if defined(__linux__) || defined(__GLIBC__)
+# include <sys/ioctl.h>
+# include <signal.h>
+# include <stdlib.h>
+# include <sys/types.h>
+# include <assert.h>
+
+# ifdef __linux__
+#  include <termio.h>
+# else /* __GLIBC__ */
+#  include <termios.h>
+# endif
+# ifdef __sparc__
+#  include <sys/param.h>
+# endif
+
+# include <errno.h>
+
+# include <sys/stat.h>
+
+# include <sys/mman.h>
+# ifdef __linux__
+#  define HAS_USL_VTS
+#  include <sys/kd.h>
+#  include <sys/vt.h>
+#  define LDGMAP GIO_SCRNMAP
+#  define LDSMAP PIO_SCRNMAP
+#  define LDNMAP LDSMAP
+#  define CLEARDTR_SUPPORT
+# endif
+
+# define POSIX_TTY
+
+#endif /* __linux__ || __GLIBC__ */
+
+/**************************************************************************/
+/* 386BSD and derivatives,  BSD/386                                       */
+/**************************************************************************/
+
+#if defined(__386BSD__) && (defined(__FreeBSD__) || defined(__NetBSD__))
+# undef __386BSD__
+#endif
+
+#ifdef CSRG_BASED
+# include <sys/ioctl.h>
+# include <signal.h>
+
+# include <termios.h>
+# define termio termios
+# define POSIX_TTY
+
+# include <errno.h>
+
+# include <sys/types.h>
+# include <sys/mman.h>
+# include <sys/stat.h>
+
+# if defined(__bsdi__)
+#  include <sys/param.h>
+# if (_BSDI_VERSION < 199510)
+#  include <i386/isa/vgaioctl.h>
+# endif
+# endif /* __bsdi__ */
+
+#endif /* CSRG_BASED */
+
+/**************************************************************************/
+/* Kernel of *BSD                                                         */
+/**************************************************************************/
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
+ defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
+
+# include <sys/param.h>
+# if defined(__FreeBSD_version) && !defined(__FreeBSD_kernel_version)
+#  define __FreeBSD_kernel_version __FreeBSD_version
+# endif
+
+# if !defined(LINKKIT)
+  /* Don't need this stuff for the Link Kit */
+#  if defined(__bsdi__)
+#   include <i386/isa/pcconsioctl.h>
+#   define CONSOLE_X_MODE_ON PCCONIOCRAW
+#   define CONSOLE_X_MODE_OFF PCCONIOCCOOK
+#   define CONSOLE_X_BELL PCCONIOCBEEP
+#  else /* __bsdi__ */
+#   ifdef SYSCONS_SUPPORT
+#    define COMPAT_SYSCONS
+#    if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
+#       if defined(__DragonFly__)  || (__FreeBSD_kernel_version >= 410000)
+#         include <sys/consio.h>
+#         include <sys/kbio.h>
+#       else
+#         include <machine/console.h>
+#       endif /* FreeBSD 4.1 RELEASE or lator */
+#    else
+#     include <sys/console.h>
+#    endif
+#   endif /* SYSCONS_SUPPORT */
+#   if defined(PCVT_SUPPORT) && !defined(__NetBSD__) && !defined(__OpenBSD__)
+#    if !defined(SYSCONS_SUPPORT)
+      /* no syscons, so include pcvt specific header file */
+#     if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#      include <machine/pcvt_ioctl.h>
+#     else
+#      include <sys/pcvt_ioctl.h>
+#     endif /* __FreeBSD_kernel__ */
+#    else /* pcvt and syscons: hard-code the ID magic */
+#     define VGAPCVTID _IOWR('V',113, struct pcvtid)
+      struct pcvtid {
+	char name[16];
+	int rmajor, rminor;
+      };
+#    endif /* PCVT_SUPPORT && SYSCONS_SUPPORT */
+#   endif /* PCVT_SUPPORT */
+#   ifdef WSCONS_SUPPORT
+#    include <dev/wscons/wsconsio.h>
+#    include <dev/wscons/wsdisplay_usl_io.h>
+#   endif /* WSCONS_SUPPORT */
+#   if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
+#    if defined(__FreeBSD_kernel_version) && (__FreeBSD_kernel_version >= 500013)
+#     include <sys/mouse.h>
+#    else
+#     undef MOUSE_GETINFO
+#     include <machine/mouse.h>
+#    endif
+#   endif
+    /* Include these definitions in case ioctl_pc.h didn't get included */
+#   ifndef CONSOLE_X_MODE_ON
+#    define CONSOLE_X_MODE_ON _IO('t',121)
+#   endif
+#   ifndef CONSOLE_X_MODE_OFF
+#    define CONSOLE_X_MODE_OFF _IO('t',122)
+#   endif
+#   ifndef CONSOLE_X_BELL
+#    define CONSOLE_X_BELL _IOW('t',123,int[2])
+#   endif
+#   ifndef CONSOLE_X_TV_ON
+#    define CONSOLE_X_TV_ON _IOW('t',155,int)
+#    define XMODE_RGB   0
+#    define XMODE_NTSC  1
+#    define XMODE_PAL   2
+#    define XMODE_SECAM 3
+#   endif
+#   ifndef CONSOLE_X_TV_OFF
+#    define CONSOLE_X_TV_OFF _IO('t',156)
+#   endif
+#ifndef CONSOLE_GET_LINEAR_INFO
+#    define CONSOLE_GET_LINEAR_INFO         _IOR('t',157,struct map_info)
+#endif
+#ifndef CONSOLE_GET_IO_INFO 
+#    define CONSOLE_GET_IO_INFO             _IOR('t',158,struct map_info)
+#endif
+#ifndef CONSOLE_GET_MEM_INFO 
+#    define CONSOLE_GET_MEM_INFO            _IOR('t',159,struct map_info)
+#endif
+#  endif /* __bsdi__ */
+# endif /* !LINKKIT */
+
+#if defined(USE_I386_IOPL) || defined(USE_AMD64_IOPL)
+#include <machine/sysarch.h>
+#endif
+
+# define CLEARDTR_SUPPORT
+
+#endif
+/* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ || __bsdi__ */
+
+/**************************************************************************/
+/* IRIX                                                                   */
+/**************************************************************************/
+
+/**************************************************************************/
+/* Generic                                                                */
+/**************************************************************************/
+
+#include <sys/wait.h>	/* May need to adjust this for other OSs */
+
+/* For PATH_MAX */
+#include "misc.h"
+
+/* 
+ * Hack originally for ISC 2.2 POSIX headers, but may apply elsewhere,
+ * and it's safe, so just do it.
+ */
+#if !defined(O_NDELAY) && defined(O_NONBLOCK)
+# define O_NDELAY O_NONBLOCK
+#endif /* !O_NDELAY && O_NONBLOCK */
+
+#if !defined(MAXHOSTNAMELEN)
+# define MAXHOSTNAMELEN 32
+#endif /* !MAXHOSTNAMELEN */
+
+#if defined(_POSIX_SOURCE)
+# include <limits.h>
+#else
+# define _POSIX_SOURCE
+# include <limits.h>
+# undef _POSIX_SOURCE
+#endif /* _POSIX_SOURCE */
+
+
+#ifndef DEV_MEM
+#define DEV_MEM "/dev/mem"
+#endif
+
+#ifndef VT_SYSREQ_DEFAULT
+#define VT_SYSREQ_DEFAULT FALSE
+#endif
+
+#define SYSCALL(call) while(((call) == -1) && (errno == EINTR))
+
+#define XF86_OS_PRIVS
+#include "xf86_OSproc.h"
+
+#ifndef NO_COMPILER_H
+#include "compiler.h"
+#endif
+
+#endif /* _XF86_OSLIB_H */
diff --git a/xorg-server/hw/xfree86/parser/xf86tokens.h b/xorg-server/hw/xfree86/parser/xf86tokens.h
index abcafcf8e..a9856064e 100644
--- a/xorg-server/hw/xfree86/parser/xf86tokens.h
+++ b/xorg-server/hw/xfree86/parser/xf86tokens.h
@@ -207,8 +207,6 @@ typedef enum {
     XKBLAYOUT,
     XKBVARIANT,
     XKBOPTIONS,
-    /* The next two have become ServerFlags options */
-    VTSYSREQ,
     /* Obsolete keyboard tokens */
     SERVERNUM,
     LEFTALT,
diff --git a/xorg-server/hw/xquartz/X11Application.m b/xorg-server/hw/xquartz/X11Application.m
index 7fd7dab3c..12ff53c88 100644
--- a/xorg-server/hw/xquartz/X11Application.m
+++ b/xorg-server/hw/xquartz/X11Application.m
@@ -356,7 +356,7 @@ static void message_kit_thread (SEL selector, NSObject *arg) {
                          */
                         _appFlags._active = YES;
 
-                        X11ApplicationSetFrontProcess();
+                        [self set_front_process:nil];
 
                         /* Get the Spaces preference for SwitchOnActivate */
                         (void)CFPreferencesAppSynchronize(CFSTR("com.apple.dock"));
diff --git a/xorg-server/hw/xquartz/pbproxy/Makefile.am b/xorg-server/hw/xquartz/pbproxy/Makefile.am
index b8b95d232..1b14dffce 100644
--- a/xorg-server/hw/xquartz/pbproxy/Makefile.am
+++ b/xorg-server/hw/xquartz/pbproxy/Makefile.am
@@ -2,6 +2,7 @@ AM_CPPFLAGS=-F/System/Library/Frameworks/ApplicationServices.framework/Framework
 	-DBUNDLE_ID_PREFIX=\"$(BUNDLE_ID_PREFIX)\"
 
 AM_CFLAGS=$(XPBPROXY_CFLAGS) 
+AM_OBJCFLAGS=$(XPBPROXY_CFLAGS)
 
 noinst_LTLIBRARIES = libxpbproxy.la
 libxpbproxy_la_SOURCES = \
diff --git a/xorg-server/include/dix-config.h.in b/xorg-server/include/dix-config.h.in
index 5facb1106..7d6cb966c 100644
--- a/xorg-server/include/dix-config.h.in
+++ b/xorg-server/include/dix-config.h.in
@@ -178,9 +178,6 @@
 /* Define to 1 if you have the `shmctl64' function. */
 #undef HAVE_SHMCTL64
 
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
@@ -402,6 +399,12 @@
 /* Use libudev for input hotplug */
 #undef CONFIG_UDEV
 
+/* Use udev_monitor_filter_add_match_tag() */
+#undef HAVE_UDEV_MONITOR_FILTER_ADD_MATCH_TAG
+
+/* Use udev_enumerate_add_match_tag() */
+#undef HAVE_UDEV_ENUMERATE_ADD_MATCH_TAG
+
 /* Use D-Bus for input hotplug */
 #undef CONFIG_NEED_DBUS
 
diff --git a/xorg-server/include/eventstr.h b/xorg-server/include/eventstr.h
index 049688ca0..2de077fd2 100644
--- a/xorg-server/include/eventstr.h
+++ b/xorg-server/include/eventstr.h
@@ -95,8 +95,7 @@ struct _DeviceEvent
     struct {
         uint8_t  mask[(MAX_VALUATORS + 7)/8]; /**< Valuator mask */
         uint8_t  mode[(MAX_VALUATORS + 7)/8]; /**< Valuator mode (Abs or Rel)*/
-        int32_t  data[MAX_VALUATORS];         /**< Valuator data */
-        int32_t  data_frac[MAX_VALUATORS];    /**< Fractional part for data */
+        double   data[MAX_VALUATORS];         /**< Valuator data */
     } valuators;
     struct {
         uint32_t base;    /**< XKB base modifiers */
@@ -113,6 +112,7 @@ struct _DeviceEvent
     Window      root; /**< Root window of the event */
     int corestate;    /**< Core key/button state BEFORE the event */
     int key_repeat;   /**< Internally-generated key repeat event */
+    uint32_t flags;   /**< Flags to be copied into the generated event */
 };
 
 
@@ -198,11 +198,10 @@ struct _RawDeviceEvent
     } detail;
     struct {
         uint8_t  mask[(MAX_VALUATORS + 7)/8]; /**< Valuator mask */
-        int32_t  data[MAX_VALUATORS];         /**< Valuator data */
-        int32_t  data_frac[MAX_VALUATORS];    /**< Fractional part for data */
-        int32_t  data_raw[MAX_VALUATORS];     /**< Valuator data as posted */
-        int32_t  data_raw_frac[MAX_VALUATORS];/**< Fractional part for data_raw */
+        double   data[MAX_VALUATORS];         /**< Valuator data */
+        double   data_raw[MAX_VALUATORS];     /**< Valuator data as posted */
     } valuators;
+    uint32_t flags;       /**< Flags to be copied into the generated event */
 };
 
 #ifdef XQUARTZ
diff --git a/xorg-server/include/exevents.h b/xorg-server/include/exevents.h
index 6e5804080..4fe6c61a9 100644
--- a/xorg-server/include/exevents.h
+++ b/xorg-server/include/exevents.h
@@ -1,312 +1,335 @@
-/************************************************************

-

-Copyright 1996 by Thomas E. Dickey <dickey@clark.net>

-

-                        All Rights Reserved

-

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

-documentation for any purpose and without fee is hereby granted,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation, and that the name of the above listed

-copyright holder(s) not be used in advertising or publicity pertaining

-to distribution of the software without specific, written prior

-permission.

-

-THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD

-TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

-AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE

-LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-********************************************************/

-

-/********************************************************************

- * Interface of 'exevents.c'

- */

-

-#ifndef EXEVENTS_H

-#define EXEVENTS_H

-

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

-#include "inputstr.h"

-

-/***************************************************************

- *              Interface available to drivers                 *

- ***************************************************************/

-

-extern _X_EXPORT int InitProximityClassDeviceStruct(

-	DeviceIntPtr           /* dev */);

-

-extern _X_EXPORT void InitValuatorAxisStruct(

-	DeviceIntPtr           /* dev */,

-	int                    /* axnum */,

-	Atom                   /* label */,

-	int                    /* minval */,

-	int                    /* maxval */,

-	int                    /* resolution */,

-	int                    /* min_res */,

-	int                    /* max_res */,

-	int                    /* mode */);

-

-/* Input device properties */

-extern _X_EXPORT void XIDeleteAllDeviceProperties(

-        DeviceIntPtr            /* device */

-);

-

-extern _X_EXPORT int XIDeleteDeviceProperty(

-        DeviceIntPtr            /* device */,

-        Atom                    /* property */,

-        Bool                    /* fromClient */

-);

-

-extern _X_EXPORT int XIChangeDeviceProperty(

-        DeviceIntPtr            /* dev */,

-        Atom                    /* property */,

-        Atom                    /* type */,

-        int                     /* format*/,

-        int                     /* mode*/,

-        unsigned long           /* len*/,

-        const pointer           /* value*/,

-        Bool                    /* sendevent*/

-        );

-

-extern _X_EXPORT int XIGetDeviceProperty(

-        DeviceIntPtr            /* dev */,

-        Atom                    /* property */,

-        XIPropertyValuePtr*     /* value */

-);

-

-extern _X_EXPORT int XISetDevicePropertyDeletable(

-        DeviceIntPtr            /* dev */,

-        Atom                    /* property */,

-        Bool                    /* deletable */

-);

-

-extern _X_EXPORT long XIRegisterPropertyHandler(

-        DeviceIntPtr         dev,

-        int (*SetProperty) (DeviceIntPtr dev,

-                            Atom property,

-                            XIPropertyValuePtr prop,

-                            BOOL checkonly),

-        int (*GetProperty) (DeviceIntPtr dev,

-                            Atom property),

-        int (*DeleteProperty) (DeviceIntPtr dev,

-                               Atom property)

-);

-

-extern _X_EXPORT void XIUnregisterPropertyHandler(

-        DeviceIntPtr          dev,

-        long                  id

-);

-

-extern _X_EXPORT Atom XIGetKnownProperty(

-        char*                 name

-);

-

-extern _X_EXPORT DeviceIntPtr XIGetDevice(xEvent *ev);

-

-extern _X_EXPORT int XIPropToInt(

-        XIPropertyValuePtr val,

-        int *nelem_return,

-        int **buf_return

-);

-

-extern _X_EXPORT int XIPropToFloat(

-        XIPropertyValuePtr val,

-        int *nelem_return,

-        float **buf_return

-);

-

-/****************************************************************************

- *                      End of driver interface                             *

- ****************************************************************************/

-

-

-/**

- * Attached to the devPrivates of each client. Specifies the version number as

- * supported by the client.

- */

-typedef struct _XIClientRec {

-        int major_version;

-        int minor_version;

-} XIClientRec, *XIClientPtr;

-

-

-typedef struct _GrabParameters {

-    int                 grabtype;               /* GRABTYPE_CORE, etc. */

-    unsigned int        ownerEvents;

-    unsigned int        this_device_mode;

-    unsigned int        other_devices_mode;

-    Window              grabWindow;

-    Window              confineTo;

-    Cursor              cursor;

-    unsigned int        modifiers;

-} GrabParameters;

-

-

-extern int

-UpdateDeviceState (

-	DeviceIntPtr           /* device */,

-	DeviceEvent*           /*  xE    */);

-

-extern void

-ProcessOtherEvent (

-	InternalEvent*         /* ev */,

-	DeviceIntPtr           /* other */);

-

-extern void

-DeviceFocusEvent(

-	DeviceIntPtr           /* dev */,

-	int                    /* type */,

-	int                    /* mode */,

-	int                    /* detail */,

-	WindowPtr              /* pWin */);

-

-extern int

-CheckGrabValues(

-        ClientPtr              /* client */,

-        GrabParameters*        /* param */);

-

-extern int

-GrabButton(

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* dev */,

-	DeviceIntPtr           /* modifier_device */,

-	int                    /* button */,

-        GrabParameters*        /* param */,

-        GrabType               /* grabtype */,

-	GrabMask*              /* eventMask */);

-

-extern int

-GrabKey(

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* dev */,

-	DeviceIntPtr           /* modifier_device */,

-	int                    /* key */,

-        GrabParameters*        /* param */,

-        GrabType               /* grabtype */,

-	GrabMask*              /* eventMask */);

-

-extern int

-GrabWindow(

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* dev */,

-	int                    /* type */,

-	GrabParameters*        /* param */,

-	GrabMask*              /* eventMask */);

-

-extern int

-SelectForWindow(

-	DeviceIntPtr           /* dev */,

-	WindowPtr              /* pWin */,

-	ClientPtr              /* client */,

-	Mask                   /* mask */,

-	Mask                   /* exclusivemasks */);

-

-extern int

-AddExtensionClient (

-	WindowPtr              /* pWin */,

-	ClientPtr              /* client */,

-	Mask                   /* mask */,

-	int                    /* mskidx */);

-

-extern void

-RecalculateDeviceDeliverableEvents(

-	WindowPtr              /* pWin */);

-

-extern int

-InputClientGone(

-	WindowPtr              /* pWin */,

-	XID                    /* id */);

-

-extern int

-SendEvent (

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* d */,

-	Window                 /* dest */,

-	Bool                   /* propagate */,

-	xEvent *               /* ev */,

-	Mask                   /* mask */,

-	int                    /* count */);

-

-extern int

-SetButtonMapping (

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* dev */,

-	int                    /* nElts */,

-	BYTE *                 /* map */);

-

-extern int

-ChangeKeyMapping(

-	ClientPtr              /* client */,

-	DeviceIntPtr           /* dev */,

-	unsigned               /* len */,

-	int                    /* type */,

-	KeyCode                /* firstKeyCode */,

-	CARD8                  /* keyCodes */,

-	CARD8                  /* keySymsPerKeyCode */,

-	KeySym *               /* map */);

-

-extern void

-DeleteWindowFromAnyExtEvents(

-	WindowPtr              /* pWin */,

-	Bool                   /* freeResources */);

-

-extern int

-MaybeSendDeviceMotionNotifyHint (

-	deviceKeyButtonPointer * /* pEvents */,

-	Mask                   /* mask */);

-

-extern void

-CheckDeviceGrabAndHintWindow (

-	WindowPtr              /* pWin */,

-	int                    /* type */,

-	deviceKeyButtonPointer * /* xE */,

-	GrabPtr                /* grab */,

-	ClientPtr              /* client */,

-	Mask                   /* deliveryMask */);

-

-extern void

-MaybeStopDeviceHint(

-	DeviceIntPtr           /* dev */,

-	ClientPtr              /* client */);

-

-extern int

-DeviceEventSuppressForWindow(

-	WindowPtr              /* pWin */,

-	ClientPtr              /* client */,

-	Mask                   /* mask */,

-	int                    /* maskndx */);

-

-extern void

-SendEventToAllWindows(

-        DeviceIntPtr           /* dev */,

-        Mask                   /* mask */,

-        xEvent *               /* ev */,

-        int                    /* count */);

-

-extern _X_HIDDEN void XI2EventSwap(

-        xGenericEvent  *              /* from */,

-        xGenericEvent  *              /* to */);

-

-/* For an event such as MappingNotify which affects client interpretation

- * of input events sent by device dev, should we notify the client, or

- * would it merely be irrelevant and confusing? */

-extern int

-XIShouldNotify(ClientPtr client, DeviceIntPtr dev);

-

-extern void

-XISendDeviceChangedEvent(DeviceIntPtr device, DeviceIntPtr master,

-                         DeviceChangedEvent *dce);

-

-extern int

-XISetEventMask(DeviceIntPtr dev, WindowPtr win, ClientPtr client,

-                           unsigned int len, unsigned char* mask);

-

-extern int

-XICheckInvalidMaskBits(ClientPtr client, unsigned char *mask, int len);

-

-#endif /* EXEVENTS_H */

+/************************************************************
+
+Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of the above listed
+copyright holder(s) not be used in advertising or publicity pertaining
+to distribution of the software without specific, written prior
+permission.
+
+THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD
+TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE
+LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+/********************************************************************
+ * Interface of 'exevents.c'
+ */
+
+#ifndef EXEVENTS_H
+#define EXEVENTS_H
+
+#include <X11/extensions/XIproto.h>
+#include "inputstr.h"
+
+/***************************************************************
+ *              Interface available to drivers                 *
+ ***************************************************************/
+
+/**
+ * Scroll flags for ::SetScrollValuator.
+ */
+enum ScrollFlags {
+    SCROLL_FLAG_NONE            = 0,
+    /**
+     * Do not emulate legacy button events for valuator events on this axis.
+     */
+    SCROLL_FLAG_DONT_EMULATE    = (1 << 1),
+    /**
+     * This axis is the preferred axis for valuator emulation for this axis'
+     * scroll type.
+     */
+    SCROLL_FLAG_PREFERRED       = (1 << 2)
+};
+
+extern _X_EXPORT int InitProximityClassDeviceStruct(
+	DeviceIntPtr           /* dev */);
+
+extern _X_EXPORT Bool InitValuatorAxisStruct(
+	DeviceIntPtr           /* dev */,
+	int                    /* axnum */,
+	Atom                   /* label */,
+	int                    /* minval */,
+	int                    /* maxval */,
+	int                    /* resolution */,
+	int                    /* min_res */,
+	int                    /* max_res */,
+	int                    /* mode */);
+
+extern _X_EXPORT Bool SetScrollValuator(
+	DeviceIntPtr           /* dev */,
+	int                    /* axnum */,
+	enum ScrollType        /* type */,
+	double                 /* increment */,
+	int                    /* flags */);
+
+/* Input device properties */
+extern _X_EXPORT void XIDeleteAllDeviceProperties(
+        DeviceIntPtr            /* device */
+);
+
+extern _X_EXPORT int XIDeleteDeviceProperty(
+        DeviceIntPtr            /* device */,
+        Atom                    /* property */,
+        Bool                    /* fromClient */
+);
+
+extern _X_EXPORT int XIChangeDeviceProperty(
+        DeviceIntPtr            /* dev */,
+        Atom                    /* property */,
+        Atom                    /* type */,
+        int                     /* format*/,
+        int                     /* mode*/,
+        unsigned long           /* len*/,
+        const pointer           /* value*/,
+        Bool                    /* sendevent*/
+        );
+
+extern _X_EXPORT int XIGetDeviceProperty(
+        DeviceIntPtr            /* dev */,
+        Atom                    /* property */,
+        XIPropertyValuePtr*     /* value */
+);
+
+extern _X_EXPORT int XISetDevicePropertyDeletable(
+        DeviceIntPtr            /* dev */,
+        Atom                    /* property */,
+        Bool                    /* deletable */
+);
+
+extern _X_EXPORT long XIRegisterPropertyHandler(
+        DeviceIntPtr         dev,
+        int (*SetProperty) (DeviceIntPtr dev,
+                            Atom property,
+                            XIPropertyValuePtr prop,
+                            BOOL checkonly),
+        int (*GetProperty) (DeviceIntPtr dev,
+                            Atom property),
+        int (*DeleteProperty) (DeviceIntPtr dev,
+                               Atom property)
+);
+
+extern _X_EXPORT void XIUnregisterPropertyHandler(
+        DeviceIntPtr          dev,
+        long                  id
+);
+
+extern _X_EXPORT Atom XIGetKnownProperty(
+        char*                 name
+);
+
+extern _X_EXPORT DeviceIntPtr XIGetDevice(xEvent *ev);
+
+extern _X_EXPORT int XIPropToInt(
+        XIPropertyValuePtr val,
+        int *nelem_return,
+        int **buf_return
+);
+
+extern _X_EXPORT int XIPropToFloat(
+        XIPropertyValuePtr val,
+        int *nelem_return,
+        float **buf_return
+);
+
+/****************************************************************************
+ *                      End of driver interface                             *
+ ****************************************************************************/
+
+
+/**
+ * Attached to the devPrivates of each client. Specifies the version number as
+ * supported by the client.
+ */
+typedef struct _XIClientRec {
+        int major_version;
+        int minor_version;
+} XIClientRec, *XIClientPtr;
+
+
+typedef struct _GrabParameters {
+    int                 grabtype;               /* GRABTYPE_CORE, etc. */
+    unsigned int        ownerEvents;
+    unsigned int        this_device_mode;
+    unsigned int        other_devices_mode;
+    Window              grabWindow;
+    Window              confineTo;
+    Cursor              cursor;
+    unsigned int        modifiers;
+} GrabParameters;
+
+
+extern int
+UpdateDeviceState (
+	DeviceIntPtr           /* device */,
+	DeviceEvent*           /*  xE    */);
+
+extern void
+ProcessOtherEvent (
+	InternalEvent*         /* ev */,
+	DeviceIntPtr           /* other */);
+
+extern void
+DeviceFocusEvent(
+	DeviceIntPtr           /* dev */,
+	int                    /* type */,
+	int                    /* mode */,
+	int                    /* detail */,
+	WindowPtr              /* pWin */);
+
+extern int
+CheckGrabValues(
+        ClientPtr              /* client */,
+        GrabParameters*        /* param */);
+
+extern int
+GrabButton(
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* dev */,
+	DeviceIntPtr           /* modifier_device */,
+	int                    /* button */,
+        GrabParameters*        /* param */,
+        GrabType               /* grabtype */,
+	GrabMask*              /* eventMask */);
+
+extern int
+GrabKey(
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* dev */,
+	DeviceIntPtr           /* modifier_device */,
+	int                    /* key */,
+        GrabParameters*        /* param */,
+        GrabType               /* grabtype */,
+	GrabMask*              /* eventMask */);
+
+extern int
+GrabWindow(
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* dev */,
+	int                    /* type */,
+	GrabParameters*        /* param */,
+	GrabMask*              /* eventMask */);
+
+extern int
+SelectForWindow(
+	DeviceIntPtr           /* dev */,
+	WindowPtr              /* pWin */,
+	ClientPtr              /* client */,
+	Mask                   /* mask */,
+	Mask                   /* exclusivemasks */);
+
+extern int
+AddExtensionClient (
+	WindowPtr              /* pWin */,
+	ClientPtr              /* client */,
+	Mask                   /* mask */,
+	int                    /* mskidx */);
+
+extern void
+RecalculateDeviceDeliverableEvents(
+	WindowPtr              /* pWin */);
+
+extern int
+InputClientGone(
+	WindowPtr              /* pWin */,
+	XID                    /* id */);
+
+extern int
+SendEvent (
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* d */,
+	Window                 /* dest */,
+	Bool                   /* propagate */,
+	xEvent *               /* ev */,
+	Mask                   /* mask */,
+	int                    /* count */);
+
+extern int
+SetButtonMapping (
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* dev */,
+	int                    /* nElts */,
+	BYTE *                 /* map */);
+
+extern int
+ChangeKeyMapping(
+	ClientPtr              /* client */,
+	DeviceIntPtr           /* dev */,
+	unsigned               /* len */,
+	int                    /* type */,
+	KeyCode                /* firstKeyCode */,
+	CARD8                  /* keyCodes */,
+	CARD8                  /* keySymsPerKeyCode */,
+	KeySym *               /* map */);
+
+extern void
+DeleteWindowFromAnyExtEvents(
+	WindowPtr              /* pWin */,
+	Bool                   /* freeResources */);
+
+extern int
+MaybeSendDeviceMotionNotifyHint (
+	deviceKeyButtonPointer * /* pEvents */,
+	Mask                   /* mask */);
+
+extern void
+CheckDeviceGrabAndHintWindow (
+	WindowPtr              /* pWin */,
+	int                    /* type */,
+	deviceKeyButtonPointer * /* xE */,
+	GrabPtr                /* grab */,
+	ClientPtr              /* client */,
+	Mask                   /* deliveryMask */);
+
+extern void
+MaybeStopDeviceHint(
+	DeviceIntPtr           /* dev */,
+	ClientPtr              /* client */);
+
+extern int
+DeviceEventSuppressForWindow(
+	WindowPtr              /* pWin */,
+	ClientPtr              /* client */,
+	Mask                   /* mask */,
+	int                    /* maskndx */);
+
+extern void
+SendEventToAllWindows(
+        DeviceIntPtr           /* dev */,
+        Mask                   /* mask */,
+        xEvent *               /* ev */,
+        int                    /* count */);
+
+extern _X_HIDDEN void XI2EventSwap(
+        xGenericEvent  *              /* from */,
+        xGenericEvent  *              /* to */);
+
+/* For an event such as MappingNotify which affects client interpretation
+ * of input events sent by device dev, should we notify the client, or
+ * would it merely be irrelevant and confusing? */
+extern int
+XIShouldNotify(ClientPtr client, DeviceIntPtr dev);
+
+extern void
+XISendDeviceChangedEvent(DeviceIntPtr device, DeviceIntPtr master,
+                         DeviceChangedEvent *dce);
+
+extern int
+XISetEventMask(DeviceIntPtr dev, WindowPtr win, ClientPtr client,
+                           unsigned int len, unsigned char* mask);
+
+extern int
+XICheckInvalidMaskBits(ClientPtr client, unsigned char *mask, int len);
+
+#endif /* EXEVENTS_H */
diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h
index 0258f4f18..6ba1ab200 100644
--- a/xorg-server/include/input.h
+++ b/xorg-server/include/input.h
@@ -68,6 +68,7 @@ SOFTWARE.
 #define POINTER_ACCELERATE	(1 << 3)
 #define POINTER_SCREEN		(1 << 4)	/* Data in screen coordinates */
 #define POINTER_NORAW		(1 << 5)	/* Don't generate RawEvents */
+#define POINTER_EMULATED	(1 << 6)	/* Event was emulated from another event */
 
 /*int constants for pointer acceleration schemes*/
 #define PtrAccelNoOp            0
@@ -583,6 +584,9 @@ extern _X_EXPORT void valuator_mask_set_range(ValuatorMask *mask,
 extern _X_EXPORT void valuator_mask_set(ValuatorMask *mask,
                                         int valuator,
                                         int data);
+extern _X_EXPORT void valuator_mask_set_double(ValuatorMask *mask,
+                                               int valuator,
+                                               double data);
 extern _X_EXPORT void valuator_mask_zero(ValuatorMask *mask);
 extern _X_EXPORT int valuator_mask_size(const ValuatorMask *mask);
 extern _X_EXPORT int valuator_mask_isset(const ValuatorMask *mask, int bit);
@@ -591,6 +595,8 @@ extern _X_EXPORT int valuator_mask_num_valuators(const ValuatorMask *mask);
 extern _X_EXPORT void valuator_mask_copy(ValuatorMask *dest,
                                          const ValuatorMask *src);
 extern _X_EXPORT int valuator_mask_get(const ValuatorMask *mask, int valnum);
+extern _X_EXPORT double valuator_mask_get_double(const ValuatorMask *mask,
+                                                 int valnum);
 
 /* InputOption handling interface */
 extern _X_EXPORT InputOption* input_option_new(InputOption *list, const char *key, const char *value);
diff --git a/xorg-server/include/inputstr.h b/xorg-server/include/inputstr.h
index 480e95671..9d4108ef5 100644
--- a/xorg-server/include/inputstr.h
+++ b/xorg-server/include/inputstr.h
@@ -75,6 +75,16 @@ extern _X_EXPORT int CountBits(const uint8_t *mask, int len);
 #define XI2MASKSIZE     ((XI2LASTEVENT + 7)/8) /* no of bits for masks */
 
 /**
+ * Scroll types for ::SetScrollValuator and the scroll type in the
+ * ::ScrollInfoPtr.
+ */
+enum ScrollType {
+    SCROLL_TYPE_NONE = 0,           /**< Not a scrolling valuator */
+    SCROLL_TYPE_VERTICAL = 8,
+    SCROLL_TYPE_HORIZONTAL = 9,
+};
+
+/**
  * This struct stores the core event mask for each client except the client
  * that created the window.
  *
@@ -252,6 +262,12 @@ typedef struct _KeyClassRec {
     struct _XkbSrvInfo *xkbInfo;
 } KeyClassRec, *KeyClassPtr;
 
+typedef struct _ScrollInfo {
+    enum ScrollType	type;
+    double		increment;
+    int			flags;
+} ScrollInfo, *ScrollInfoPtr;
+
 typedef struct _AxisInfo {
     int		resolution;
     int		min_resolution;
@@ -260,6 +276,7 @@ typedef struct _AxisInfo {
     int		max_value;
     Atom	label;
     CARD8	mode;
+    ScrollInfo  scroll;
 } AxisInfo, *AxisInfoPtr;
 
 typedef struct _ValuatorAccelerationRec {
@@ -283,6 +300,8 @@ typedef struct _ValuatorClassRec {
     unsigned short	  numAxes;
     double		  *axisVal; /* always absolute, but device-coord system */
     ValuatorAccelerationRec	accelScheme;
+    int                   h_scroll_axis; /* horiz smooth-scrolling axis */
+    int                   v_scroll_axis; /* vert smooth-scrolling axis */
 } ValuatorClassRec;
 
 typedef struct _ButtonClassRec {
@@ -521,10 +540,10 @@ typedef struct _DeviceIntRec {
      * remainder supports acceleration
      */
     struct {
-        int             valuators[MAX_VALUATORS];
-        float           remainder[MAX_VALUATORS];
+        double          valuators[MAX_VALUATORS];
         int             numValuators;
         DeviceIntPtr    slave;
+        ValuatorMask    *scroll;
     } last;
 
     /* Input device property handling. */
diff --git a/xorg-server/include/inpututils.h b/xorg-server/include/inpututils.h
index 63e1a263a..47e242d87 100644
--- a/xorg-server/include/inpututils.h
+++ b/xorg-server/include/inpututils.h
@@ -34,7 +34,7 @@
 struct _ValuatorMask {
     int8_t      last_bit; /* highest bit set in mask */
     uint8_t     mask[(MAX_VALUATORS + 7)/8];
-    int         valuators[MAX_VALUATORS]; /* valuator data */
+    double      valuators[MAX_VALUATORS]; /* valuator data */
 };
 
 extern void verify_internal_event(const InternalEvent *ev);
diff --git a/xorg-server/include/misc.h b/xorg-server/include/misc.h
index 1fea73ec3..dc039113d 100644
--- a/xorg-server/include/misc.h
+++ b/xorg-server/include/misc.h
@@ -261,14 +261,16 @@ version_compare(uint16_t a_major, uint16_t a_minor,
 #define SwapRestL(stuff) \
     SwapLongs((CARD32 *)(stuff + 1), LengthRestL(stuff))
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
 void __attribute__((error("wrong sized variable passed to swap"))) wrong_size(void);
 #else
 static inline void wrong_size(void)
 {
 }
+#endif
 
-static inline void __builtin_constant_p(int x)
+#if !(defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C < 0x590)))
+static inline int __builtin_constant_p(int x)
 {
 	return 0;
 }
@@ -277,7 +279,7 @@ static inline void __builtin_constant_p(int x)
 /* byte swap a 32-bit value */
 static inline void swap_uint32(uint32_t *x)
 {
-	char n = ((char *) &x)[0];
+	char n = ((char *) x)[0];
 	((char *) x)[0] = ((char *) x)[3];
 	((char *) x)[3] = n;
 	n = ((char *) x)[1];
diff --git a/xorg-server/include/protocol-versions.h b/xorg-server/include/protocol-versions.h
index 7b7a9f53c..832bcf756 100644
--- a/xorg-server/include/protocol-versions.h
+++ b/xorg-server/include/protocol-versions.h
@@ -127,7 +127,7 @@
 
 /* X Input */
 #define SERVER_XI_MAJOR_VERSION			2
-#define SERVER_XI_MINOR_VERSION			0
+#define SERVER_XI_MINOR_VERSION			1
 
 /* XKB */
 #define SERVER_XKB_MAJOR_VERSION		1
diff --git a/xorg-server/include/ptrveloc.h b/xorg-server/include/ptrveloc.h
index 6ca309c8c..4f76b0094 100644
--- a/xorg-server/include/ptrveloc.h
+++ b/xorg-server/include/ptrveloc.h
@@ -47,9 +47,9 @@ struct _DeviceVelocityRec;
  * profile
  * returns actual acceleration depending on velocity, acceleration control,...
  */
-typedef float (*PointerAccelerationProfileFunc)
+typedef double (*PointerAccelerationProfileFunc)
               (DeviceIntPtr dev, struct _DeviceVelocityRec* vel,
-               float velocity, float threshold, float accelCoeff);
+               double velocity, double threshold, double accelCoeff);
 
 /**
  * a motion history, with just enough information to
@@ -57,8 +57,8 @@ typedef float (*PointerAccelerationProfileFunc)
  * a more or less straight line
  */
 typedef struct _MotionTracker {
-    int dx, dy;     /* accumulated delta for each axis */
-    int time;         /* time of creation */
+    double dx, dy;  /* accumulated delta for each axis */
+    int time;       /* time of creation */
     int dir;        /* initial direction bitfield */
 } MotionTracker, *MotionTrackerPtr;
 
@@ -69,17 +69,17 @@ typedef struct _DeviceVelocityRec {
     MotionTrackerPtr tracker;
     int num_tracker;
     int cur_tracker;        /* current index */
-    float   velocity;       /* velocity as guessed by algorithm */
-    float   last_velocity;  /* previous velocity estimate */
-    int     last_dx;      /* last time-difference */
-    int     last_dy ;     /* phase of last/current estimate */
-    float   corr_mul;       /* config: multiply this into velocity */
-    float   const_acceleration;  /* config: (recipr.) const deceleration */
-    float   min_acceleration;    /* config: minimum acceleration */
+    double  velocity;       /* velocity as guessed by algorithm */
+    double  last_velocity;  /* previous velocity estimate */
+    double  last_dx;        /* last time-difference */
+    double  last_dy;        /* phase of last/current estimate */
+    double  corr_mul;       /* config: multiply this into velocity */
+    double  const_acceleration;  /* config: (recipr.) const deceleration */
+    double  min_acceleration;    /* config: minimum acceleration */
     short   reset_time;     /* config: reset non-visible state after # ms */
     short   use_softening;  /* config: use softening of mouse values */
-    float   max_rel_diff;   /* config: max. relative difference */
-    float   max_diff;       /* config: max. difference */
+    double  max_rel_diff;   /* config: max. relative difference */
+    double  max_diff;       /* config: max. difference */
     int     initial_range;  /* config: max. offset used as initial velocity */
     Bool    average_accel;  /* config: average acceleration over velocity */
     PointerAccelerationProfileFunc Profile;
@@ -107,11 +107,11 @@ extern _X_EXPORT void
 InitTrackers(DeviceVelocityPtr vel, int ntracker);
 
 extern _X_EXPORT BOOL
-ProcessVelocityData2D(DeviceVelocityPtr vel, int dx, int dy, int time);
+ProcessVelocityData2D(DeviceVelocityPtr vel, double dx, double dy, int time);
 
-extern _X_EXPORT float
+extern _X_EXPORT double
 BasicComputeAcceleration(DeviceIntPtr dev, DeviceVelocityPtr vel,
-    float velocity, float threshold, float acc);
+    double velocity, double threshold, double acc);
 
 extern _X_EXPORT void
 FreeVelocityData(DeviceVelocityPtr vel);
diff --git a/xorg-server/include/xserver-properties.h b/xorg-server/include/xserver-properties.h
index bf50042d0..18b54ba32 100644
--- a/xorg-server/include/xserver-properties.h
+++ b/xorg-server/include/xserver-properties.h
@@ -77,6 +77,8 @@
 #define AXIS_LABEL_PROP_REL_DIAL        "Rel Dial"
 #define AXIS_LABEL_PROP_REL_WHEEL       "Rel Vert Wheel"
 #define AXIS_LABEL_PROP_REL_MISC        "Rel Misc"
+#define AXIS_LABEL_PROP_REL_VSCROLL     "Rel Vert Scroll"
+#define AXIS_LABEL_PROP_REL_HSCROLL     "Rel Horiz Scroll"
 
 /*
  * Absolute axes
diff --git a/xorg-server/render/render.c b/xorg-server/render/render.c
index cc13dbc2a..ff75409cb 100644
--- a/xorg-server/render/render.c
+++ b/xorg-server/render/render.c
@@ -52,11 +52,7 @@
 #include "panoramiXsrv.h"
 #endif
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
 
 static int ProcRenderQueryVersion (ClientPtr pClient);
 static int ProcRenderQueryPictFormats (ClientPtr pClient);
diff --git a/xorg-server/test/input.c b/xorg-server/test/input.c
index b8dad1c60..afc4d4d99 100644
--- a/xorg-server/test/input.c
+++ b/xorg-server/test/input.c
@@ -52,6 +52,7 @@ static void dix_init_valuators(void)
 {
     DeviceIntRec dev;
     ValuatorClassPtr val;
+    AxisInfoPtr axis;
     const int num_axes = 2;
     int i;
     Atom atoms[MAX_VALUATORS] = { 0 };
@@ -78,6 +79,62 @@ static void dix_init_valuators(void)
     }
 
     assert(dev.last.numValuators == num_axes);
+
+    /* invalid increment */
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_VERTICAL, 0.0, SCROLL_FLAG_NONE) == FALSE);
+    /* invalid type */
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_VERTICAL - 1, 1.0, SCROLL_FLAG_NONE) == FALSE);
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_HORIZONTAL + 1, 1.0, SCROLL_FLAG_NONE) == FALSE);
+    /* invalid axisnum */
+    assert(SetScrollValuator(&dev, 2, SCROLL_TYPE_HORIZONTAL, 1.0, SCROLL_FLAG_NONE) == FALSE);
+
+    /* valid */
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE);
+    axis = &dev.valuator->axes[0];
+    assert(axis->scroll.increment == 3.0);
+    assert(axis->scroll.type == SCROLL_TYPE_VERTICAL);
+    assert(axis->scroll.flags == 0);
+
+    /* valid */
+    assert(SetScrollValuator(&dev, 1, SCROLL_TYPE_HORIZONTAL, 2.0, SCROLL_FLAG_NONE) == TRUE);
+    axis = &dev.valuator->axes[1];
+    assert(axis->scroll.increment == 2.0);
+    assert(axis->scroll.type == SCROLL_TYPE_HORIZONTAL);
+    assert(axis->scroll.flags == 0);
+
+    /* can add another non-preffered axis */
+    assert(SetScrollValuator(&dev, 1, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE);
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_HORIZONTAL, 5.0, SCROLL_FLAG_NONE) == TRUE);
+
+    /* can overwrite with Preferred */
+    assert(SetScrollValuator(&dev, 1, SCROLL_TYPE_VERTICAL, 5.5, SCROLL_FLAG_PREFERRED) == TRUE);
+    axis = &dev.valuator->axes[1];
+    assert(axis->scroll.increment == 5.5);
+    assert(axis->scroll.type == SCROLL_TYPE_VERTICAL);
+    assert(axis->scroll.flags == SCROLL_FLAG_PREFERRED);
+
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_HORIZONTAL, 8.8, SCROLL_FLAG_PREFERRED) == TRUE);
+    axis = &dev.valuator->axes[0];
+    assert(axis->scroll.increment == 8.8);
+    assert(axis->scroll.type == SCROLL_TYPE_HORIZONTAL);
+    assert(axis->scroll.flags == SCROLL_FLAG_PREFERRED);
+
+    /* can overwrite as none */
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE, 5.0,
+                SCROLL_FLAG_NONE) == TRUE);
+    axis = &dev.valuator->axes[0];
+    assert(axis->scroll.type == SCROLL_TYPE_NONE);
+
+    /* can overwrite axis with new settings */
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE);
+    axis = &dev.valuator->axes[0];
+    assert(axis->scroll.type == SCROLL_TYPE_VERTICAL);
+    assert(axis->scroll.increment == 5.0);
+    assert(axis->scroll.flags == SCROLL_FLAG_NONE);
+    assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE);
+    assert(axis->scroll.type == SCROLL_TYPE_VERTICAL);
+    assert(axis->scroll.increment == 3.0);
+    assert(axis->scroll.flags == SCROLL_FLAG_NONE);
 }
 
 /* just check the known success cases, and that error cases set the client's
@@ -1089,12 +1146,16 @@ static void dix_input_valuator_masks(void)
 {
     ValuatorMask *mask = NULL, *copy;
     int nvaluators = MAX_VALUATORS;
-    int valuators[nvaluators];
+    double valuators[nvaluators];
+    int val_ranged[nvaluators];
     int i;
     int first_val, num_vals;
 
     for (i = 0; i < nvaluators; i++)
-        valuators[i] = i;
+    {
+        valuators[i] = i + 0.5;
+        val_ranged[i] = i;
+    }
 
     mask = valuator_mask_new(nvaluators);
     assert(mask != NULL);
@@ -1104,9 +1165,10 @@ static void dix_input_valuator_masks(void)
     for (i = 0; i < nvaluators; i++)
     {
         assert(!valuator_mask_isset(mask, i));
-        valuator_mask_set(mask, i, valuators[i]);
+        valuator_mask_set_double(mask, i, valuators[i]);
         assert(valuator_mask_isset(mask, i));
-        assert(valuator_mask_get(mask, i) == valuators[i]);
+        assert(valuator_mask_get(mask, i) == trunc(valuators[i]));
+        assert(valuator_mask_get_double(mask, i) == valuators[i]);
         assert(valuator_mask_size(mask) == i + 1);
         assert(valuator_mask_num_valuators(mask) == i + 1);
     }
@@ -1132,7 +1194,7 @@ static void dix_input_valuator_masks(void)
     first_val = 5;
     num_vals = 6;
 
-    valuator_mask_set_range(mask, first_val, num_vals, valuators);
+    valuator_mask_set_range(mask, first_val, num_vals, val_ranged);
     assert(valuator_mask_size(mask) == first_val + num_vals);
     assert(valuator_mask_num_valuators(mask) == num_vals);
     for (i = 0; i < nvaluators; i++)
@@ -1142,7 +1204,9 @@ static void dix_input_valuator_masks(void)
         else
         {
             assert(valuator_mask_isset(mask, i));
-            assert(valuator_mask_get(mask, i) == valuators[i - first_val]);
+            assert(valuator_mask_get(mask, i) == val_ranged[i - first_val]);
+            assert(valuator_mask_get_double(mask, i) ==
+                    val_ranged[i - first_val]);
         }
     }
 
@@ -1156,6 +1220,8 @@ static void dix_input_valuator_masks(void)
     {
         assert(valuator_mask_isset(mask, i) == valuator_mask_isset(copy, i));
         assert(valuator_mask_get(mask, i) == valuator_mask_get(copy, i));
+        assert(valuator_mask_get_double(mask, i) ==
+                valuator_mask_get_double(copy, i));
     }
 
     valuator_mask_free(&mask);
diff --git a/xorg-server/test/xi2/protocol-common.c b/xorg-server/test/xi2/protocol-common.c
index 423453358..56d6bd268 100644
--- a/xorg-server/test/xi2/protocol-common.c
+++ b/xorg-server/test/xi2/protocol-common.c
@@ -29,6 +29,8 @@
 #include "extinit.h" /* for XInputExtensionInit */
 #include "exglobals.h"
 #include "xkbsrv.h" /* for XkbInitPrivates */
+#include "xserver-properties.h"
+#include <X11/extensions/XI2.h>
 
 #include "protocol-common.h"
 
@@ -63,6 +65,65 @@ static void fake_init_sprite(DeviceIntPtr dev)
     sprite->physLimits.y2 = screen.height;
 }
 
+/* This is essentially CorePointerProc with ScrollAxes added */
+static int
+TestPointerProc(DeviceIntPtr pDev, int what)
+{
+#define NBUTTONS 10
+#define NAXES 4
+    BYTE map[NBUTTONS + 1];
+    int i = 0;
+    Atom btn_labels[NBUTTONS] = {0};
+    Atom axes_labels[NAXES] = {0};
+
+    switch (what) {
+    case DEVICE_INIT:
+        for (i = 1; i <= NBUTTONS; i++)
+            map[i] = i;
+
+	btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
+	btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
+	btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
+	btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
+	btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+	btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+	btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+	/* don't know about the rest */
+
+	axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
+	axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
+	axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_VSCROLL);
+	axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_HSCROLL);
+
+        if (!InitPointerDeviceStruct((DevicePtr)pDev, map, NBUTTONS, btn_labels,
+                                (PtrCtrlProcPtr)NoopDDA,
+                                GetMotionHistorySize(), NAXES, axes_labels))
+        {
+            ErrorF("Could not initialize device '%s'. Out of memory.\n",
+                   pDev->name);
+            return BadAlloc;
+        }
+        pDev->valuator->axisVal[0] = screenInfo.screens[0]->width / 2;
+        pDev->last.valuators[0] = pDev->valuator->axisVal[0];
+        pDev->valuator->axisVal[1] = screenInfo.screens[0]->height / 2;
+        pDev->last.valuators[1] = pDev->valuator->axisVal[1];
+
+        SetScrollValuator(pDev, 2, SCROLL_TYPE_VERTICAL, 2.4, SCROLL_FLAG_NONE);
+        SetScrollValuator(pDev, 3, SCROLL_TYPE_HORIZONTAL, 3.5, SCROLL_FLAG_PREFERRED);
+        break;
+
+    case DEVICE_CLOSE:
+        break;
+
+    default:
+        break;
+    }
+
+    return Success;
+
+#undef NBUTTONS
+#undef NAXES
+}
 /**
  * Create and init 2 master devices (VCP + VCK) and two slave devices, one
  * default mouse, one default keyboard.
@@ -84,7 +145,7 @@ struct devices init_devices(void)
     EnableDevice(devices.vck, FALSE);
 
     AllocDevicePair(&client, "", &devices.mouse, &devices.kbd,
-                    CorePointerProc, CoreKeyboardProc, FALSE);
+                    TestPointerProc, CoreKeyboardProc, FALSE);
     ActivateDevice(devices.mouse, FALSE);
     ActivateDevice(devices.kbd, FALSE);
     EnableDevice(devices.mouse, FALSE);
diff --git a/xorg-server/test/xi2/protocol-eventconvert.c b/xorg-server/test/xi2/protocol-eventconvert.c
index 6ec94be6c..bfa23b51f 100644
--- a/xorg-server/test/xi2/protocol-eventconvert.c
+++ b/xorg-server/test/xi2/protocol-eventconvert.c
@@ -41,6 +41,7 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
     int nvals = 0;
     int bits_set;
     int len;
+    uint32_t flagmask = 0;
 
     if (swap)
     {
@@ -51,6 +52,7 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
         swapl(&out->time);
         swapl(&out->detail);
         swaps(&out->valuators_len);
+        swapl(&out->flags);
     }
 
 
@@ -61,7 +63,17 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
     assert(out->detail == in->detail.button);
     assert(out->deviceid == in->deviceid);
     assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask))));
-    assert(out->flags == 0); /* FIXME: we don't set the flags yet */
+
+    switch (in->type) {
+    case ET_RawMotion:
+    case ET_RawButtonPress:
+    case ET_RawButtonRelease:
+        flagmask = XIPointerEmulated;
+        break;
+    default:
+        flagmask = 0;
+    }
+    assert((out->flags & ~flagmask) == 0);
 
     ptr = (unsigned char*)&out[1];
     bits_set = 0;
@@ -92,8 +104,8 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
             value = (FP3232*)(((unsigned char*)&out[1]) + out->valuators_len * 4);
             value += nvals;
 
-            vi.integral = in->valuators.data[i];
-            vi.frac = in->valuators.data_frac[i];
+            vi.integral = trunc(in->valuators.data[i]);
+            vi.frac = in->valuators.data[i] - vi.integral;
 
             vo.integral = value->integral;
             vo.frac = value->frac;
@@ -108,8 +120,8 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
 
             raw_value = value + bits_set;
 
-            vi.integral = in->valuators.data_raw[i];
-            vi.frac = in->valuators.data_raw_frac[i];
+            vi.integral = trunc(in->valuators.data_raw[i]);
+            vi.frac = in->valuators.data_raw[i] - vi.integral;
 
             vo.integral = raw_value->integral;
             vo.frac = raw_value->frac;
@@ -247,10 +259,8 @@ static void test_convert_XIRawEvent(void)
     {
         XISetMask(in.valuators.mask, i);
 
-        in.valuators.data[i] = i;
-        in.valuators.data_raw[i] = i + 10;
-        in.valuators.data_frac[i] = i + 20;
-        in.valuators.data_raw_frac[i] = i + 30;
+        in.valuators.data[i] = i + (i * 0.0010);
+        in.valuators.data_raw[i] = (i + 10) + (i * 0.0030);
         test_XIRawEvent(&in);
         XIClearMask(in.valuators.mask, i);
     }
@@ -305,6 +315,11 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
     assert(out->sourceid == in->sourceid);
 
     switch (in->type) {
+        case ET_ButtonPress:
+        case ET_Motion:
+        case ET_ButtonRelease:
+            flagmask = XIPointerEmulated;
+            break;
         case ET_KeyPress:
             flagmask = XIKeyRepeat;
             break;
@@ -375,8 +390,8 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
             {
                 FP3232 vi, vo;
 
-                vi.integral = in->valuators.data[i];
-                vi.frac = in->valuators.data_frac[i];
+                vi.integral = trunc(in->valuators.data[i]);
+                vi.frac = (in->valuators.data[i] - vi.integral) * (1UL << 32);
 
                 vo = *values;
 
@@ -618,8 +633,7 @@ static void test_convert_XIDeviceEvent(void)
     {
         XISetMask(in.valuators.mask, i);
 
-        in.valuators.data[i] = i;
-        in.valuators.data_frac[i] = i + 20;
+        in.valuators.data[i] = i + (i * 0.0020);
         test_XIDeviceEvent(&in);
         XIClearMask(in.valuators.mask, i);
     }
diff --git a/xorg-server/test/xi2/protocol-xiquerydevice.c b/xorg-server/test/xi2/protocol-xiquerydevice.c
index 47eb5b14c..63d725f28 100644
--- a/xorg-server/test/xi2/protocol-xiquerydevice.c
+++ b/xorg-server/test/xi2/protocol-xiquerydevice.c
@@ -127,7 +127,7 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
                 dev = devices.mouse;
                 assert(info->use == XISlavePointer);
                 assert(info->attachment == devices.vcp->id);
-                assert(info->num_classes == 3); /* 2 axes + button */
+                assert(info->num_classes == 7); /* 4 axes + button + 2 scroll*/
                 break;
             case 5:  /* keyboard */
                 dev = devices.kbd;
@@ -183,11 +183,48 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
                         }
                         break;
                     }
-                case 2: /* VCP and mouse have the same properties */
                 case 4:
                     {
                         assert(any->type == XIButtonClass ||
-                                any->type == XIValuatorClass);
+                               any->type == XIValuatorClass ||
+                               any->type == XIScrollClass);
+
+                        if (any->type == XIScrollClass)
+                        {
+                            xXIScrollInfo *si = (xXIScrollInfo*)any;
+
+                            if (client->swapped)
+                            {
+                                swaps(&si->number);
+                                swaps(&si->scroll_type);
+                                swapl(&si->increment.integral);
+                                swapl(&si->increment.frac);
+                            }
+                            assert(si->length == 6);
+                            assert(si->number == 2 || si->number == 3);
+                            if (si->number == 2) {
+                                assert(si->scroll_type == XIScrollTypeVertical);
+                                assert(!si->flags);
+                            }
+                            if (si->number == 3) {
+                                assert(si->scroll_type == XIScrollTypeHorizontal);
+                                assert(si->flags & XIScrollFlagPreferred);
+                                assert(!(si->flags & ~XIScrollFlagPreferred));
+                            }
+
+                            assert(si->increment.integral == si->number);
+                            /* FIXME: frac testing with float/FP issues? */
+                            assert(si->increment.frac > 0.3  * (1UL << 32));
+                            assert(si->increment.frac < 0.6  * (1UL << 32));
+                        }
+
+                    }
+                    /* fall through */
+                case 2: /* VCP and mouse have the same properties except for scroll */
+                    {
+                        if (info->deviceid == 2 ) /* VCP */
+                            assert(any->type == XIButtonClass ||
+                                   any->type == XIValuatorClass);
 
                         if (any->type == XIButtonClass)
                         {
@@ -217,8 +254,10 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
                             }
 
                             assert(vi->length == 11);
-                            assert(vi->number == 0 ||
-                                     vi->number == 1);
+                            assert(vi->number >= 0 && vi->number < 4);
+                            if (info->deviceid == 2) /* VCP */
+                                assert(vi->number < 2);
+
                             assert(vi->mode == XIModeRelative);
                             /* device was set up as relative, so standard
                              * values here. */
diff --git a/xorg-server/xkb/xkbAccessX.c b/xorg-server/xkb/xkbAccessX.c
index 4115ff27d..d246827ea 100644
--- a/xorg-server/xkb/xkbAccessX.c
+++ b/xorg-server/xkb/xkbAccessX.c
@@ -37,6 +37,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XIproto.h>
 #include "inputstr.h"
 #include "eventstr.h"
+#include "inpututils.h"
 #include <xkbsrv.h>
 #if !defined(WIN32)
 #include <sys/time.h>
diff --git a/xorg-server/xkeyboard-config/NEWS b/xorg-server/xkeyboard-config/NEWS
index e32b2c318..00ae0db79 100644
--- a/xorg-server/xkeyboard-config/NEWS
+++ b/xorg-server/xkeyboard-config/NEWS
@@ -1,3 +1,4 @@
+2.4.1	Critical bug fixed: many Ctl+Alt combinations broken
 2.4	9 bugs fixed, a number of translations updated
 2.3	First scheduled (and reasonably polished) release since GNOME3.
 	Serious cleanup of descriptions
diff --git a/xorg-server/xkeyboard-config/configure.in b/xorg-server/xkeyboard-config/configure.in
index 6a395aab0..fa4baef95 100644
--- a/xorg-server/xkeyboard-config/configure.in
+++ b/xorg-server/xkeyboard-config/configure.in
@@ -1,4 +1,4 @@
-AC_INIT(xkeyboard-config, 2.4)
+AC_INIT(xkeyboard-config, 2.4.1)
 AC_CONFIG_SRCDIR(rules/base.xml.in)
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AM_MAINTAINER_MODE
diff --git a/xorg-server/xkeyboard-config/symbols/in b/xorg-server/xkeyboard-config/symbols/in
index 7b7300f40..84d9b06f8 100644
--- a/xorg-server/xkeyboard-config/symbols/in
+++ b/xorg-server/xkeyboard-config/symbols/in
@@ -172,7 +172,7 @@ xkb_symbols "bolnagri" {
 
 partial alphanumeric_keys
 xkb_symbols "ben" {
-    name[Group1]= "Bengali";
+    name[Group1]= "Bengali (India)";
 
       // Mainly numbers.
       key <AE01> { [      U09E7 		]	};
@@ -237,7 +237,7 @@ xkb_symbols "ben" {
 };
 
 xkb_symbols "ben_probhat" {
- name[Group1]= "Bengali (Probhat)";
+ name[Group1]= "Bengali (India, Probhat)";
    key <ESC>  { [ Escape ] };
 
 // numbers
@@ -312,7 +312,7 @@ xkb_symbols "ben_probhat" {
 // Bengali Baishakhi, Bengali Baishakhi Inscript, Bengali Bornona, Uni Gitanjali Layouts are added by Promathesh Mandal <promathesh812004@gmail.com>
 
 xkb_symbols "ben_baishakhi" {
- name[Group1]= "Bengali (Baishakhi)";
+ name[Group1]= "Bengali (India, Baishakhi)";
    key <ESC>   { [ Escape 					] };
 
 // numbers
@@ -389,7 +389,7 @@ xkb_symbols "ben_baishakhi" {
 };
 
 xkb_symbols "ben_inscript" {
-    name[Group1]= "Bengali (Baishakhi Inscript)";
+    name[Group1]= "Bengali (India, Baishakhi Inscript)";
 
       // Mainly numbers.
       key <TLDE> { [      0x100200D, 0x100200C	] 	};
@@ -455,7 +455,7 @@ xkb_symbols "ben_inscript" {
 };
 
 xkb_symbols "ben_gitanjali" {
- name[Group1]= "Bengali (Uni Gitanjali)";
+ name[Group1]= "Bengali (India, Uni Gitanjali)";
    key <ESC>   { [ Escape			] };
 
 // numbers
@@ -533,7 +533,7 @@ xkb_symbols "ben_gitanjali" {
 
 
 xkb_symbols "ben_bornona" {
- name[Group1]= "Bengali (Bornona)";
+ name[Group1]= "Bengali (India, Bornona)";
    key <ESC>  { [ Escape 					] };
 
 // numbers
diff --git a/xorg-server/xkeyboard-config/symbols/keypad b/xorg-server/xkeyboard-config/symbols/keypad
index fb3469850..e85aaacbd 100644
--- a/xorg-server/xkeyboard-config/symbols/keypad
+++ b/xorg-server/xkeyboard-config/symbols/keypad
@@ -1,633 +1,633 @@
-partial hidden keypad_keys

-xkb_symbols "overlay" {

-    include "keypad(overlay1)"

-};

-

-partial hidden keypad_keys

-xkb_symbols "overlay1" {

-

-    // Begin "Keypad" section

-

-    key  <KP7> {	[  KP_Home	],	overlay1=<KO7>	};

-    key  <KP8> {	[  KP_Up	],	overlay1=<KO8>	};

-    key  <KP9> {	[  KP_Prior	],	overlay1=<KO9>	};

-

-    key  <KP4> {	[  KP_Left	],	overlay1=<KO4>	};

-    key  <KP5> {	[  KP_Begin	],	overlay1=<KO5>	};

-    key  <KP6> {	[  KP_Right	],	overlay1=<KO6>	};

-

-    key  <KP1> {	[  KP_End	],	overlay1=<KO1>	};

-    key  <KP2> {	[  KP_Down	],	overlay1=<KO2>	};

-    key  <KP3> {	[  KP_Next	],	overlay1=<KO3>	};

-

-    key  <KP0> {	[  KP_Insert	],	overlay1=<KO0>	};

-    key <KPDL> {  	[  KP_Delete	],	overlay1=<KODL>	};

-

-    key  <KO7> {	[  KP_7	]	};

-    key  <KO8> {	[  KP_8	]	};

-    key  <KO9> {	[  KP_9	]	};

-

-    key  <KO4> {	[  KP_4	]	};

-    key  <KO5> {	[  KP_5	]	};

-    key  <KO6> {	[  KP_6	]	};

-

-    key  <KO1> {	[  KP_1	]	};

-    key  <KO2> {	[  KP_2	]	};

-    key  <KO3> {	[  KP_3	]	};

-

-    key  <KO0> {	[  KP_0	]	};

-    key <KODL> {  	[  KP_Decimal ]	};

-

-    // End "Keypad" section

-};

-

-partial hidden keypad_keys

-xkb_symbols "overlay2" {

-

-    // Begin "Keypad" section

-

-    key  <KP7> {	[  KP_Home	],	overlay2=<KO7>	};

-    key  <KP8> {	[  KP_Up	],	overlay2=<KO8>	};

-    key  <KP9> {	[  KP_Prior	],	overlay2=<KO9>	};

-

-    key  <KP4> {	[  KP_Left	],	overlay2=<KO4>	};

-    key  <KP5> {	[  KP_Begin	],	overlay2=<KO5>	};

-    key  <KP6> {	[  KP_Right	],	overlay2=<KO6>	};

-

-    key  <KP1> {	[  KP_End	],	overlay2=<KO1>	};

-    key  <KP2> {	[  KP_Down	],	overlay2=<KO2>	};

-    key  <KP3> {	[  KP_Next	],	overlay2=<KO3>	};

-

-    key  <KP0> {	[  KP_Insert	],	overlay2=<KO0>	};

-    key <KPDL> {  	[  KP_Delete	],	overlay2=<KODL>	};

-

-    key  <KO7> {	[  KP_7	]	};

-    key  <KO8> {	[  KP_8	]	};

-    key  <KO9> {	[  KP_9	]	};

-

-    key  <KO4> {	[  KP_4	]	};

-    key  <KO5> {	[  KP_5	]	};

-    key  <KO6> {	[  KP_6	]	};

-

-    key  <KO1> {	[  KP_1	]	};

-    key  <KO2> {	[  KP_2	]	};

-    key  <KO3> {	[  KP_3	]	};

-

-    key  <KO0> {	[  KP_0	]	};

-    key <KODL> {  	[  KP_Decimal ]	};

-

-    // End "Keypad" section

-};

-

-partial hidden default keypad_keys

-xkb_symbols "x11" {

-// Ungrab cancels server/keyboard/pointer grabs

-    key <KPDV> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Divide,	XF86_Ungrab ]

-    };

-

-// ClsGrb kills whichever client has a grab in effect

-    key <KPMU> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Multiply,	XF86_ClearGrab ]

-    };

-

-// -VMode switches to the previous video mode

-    key <KPSU> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Subtract,	XF86_Prev_VMode ]

-    };

-

-    key  <KP7> {	[  KP_Home,	KP_7	]	};

-    key  <KP8> {	[  KP_Up,	KP_8	]	};

-    key  <KP9> {	[  KP_Prior,	KP_9	]	};

-

-// +VMode switches to the next video mode

-    key <KPAD> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Add,	XF86_Next_VMode ]

-    };

-

-    key  <KP4> {	[  KP_Left,	KP_4	]	};

-    key  <KP5> {	[  KP_Begin,	KP_5	]	};

-    key  <KP6> {	[  KP_Right,	KP_6	]	};

-

-    key  <KP1> {	[  KP_End,	KP_1	]	};

-    key  <KP2> {	[  KP_Down,	KP_2	]	};

-    key  <KP3> {	[  KP_Next,	KP_3	]	};

-    key <KPEN> {	[  	KP_Enter	]	};

-    key <KPEQ> {	[  	KP_Equal	]	};

-

-    key  <KP0> {	[  KP_Insert,	KP_0	]	};

-    key <KPDL> {  	[  KP_Delete,	KP_Decimal ]	};

-    key <KPPT> {  	[  KP_Decimal,	KP_Decimal ]	};

-};

-

-

-// Legacy PC keypad definition

-// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "legacy" {

-

-    include "keypad(core)"

-    include "keypad(legacymath)"

-    include "keypad(legacynumber)"

-    include "kpdl(dot)"

-};

-

-

-// Legacy Wang 725-3771-ae and 725-3771-uk keypad definition

-// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "legacy_wang" {

-

-    include "keypad(core)"

-    include "keypad(legacymath)"

-    include "keypad(legacynumber_wang)"

-    include "kpdl(dot)"

-};

-

-

-// Complete new keypad definition

-// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "oss" {

-

-    include "keypad(core)"

-    include "keypad(ossmath)"

-    include "keypad(ossnumber)"

-    include "kpdl(dotoss)"

-};

-

-

-// Latin9 restriction of new keypad definition

-// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "oss_latin9" {

-

-    include "keypad(core)"

-    include "keypad(ossmath_latin9)"

-    include "keypad(legacynumber)"

-    include "kpdl(dotoss_latin9)"

-};

-

-

-// Wang 725-3771-ae and 725-3771-uk keypad variant of oss keypad

-// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "oss_wang" {

-

-    include "keypad(core)"

-    include "keypad(ossmath)"

-    include "keypad(ossnumber_wang)"

-    include "kpdl(dotoss)"

-};

-

-

-// Forward-looking keypad definition

-// Won't work with applications that make ASCII assumptions

-// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "future" {

-

-    include "keypad(core)"

-    include "keypad(futuremath)"

-    include "keypad(ossnumber)"

-    include "kpdl(commaoss)"

-};

-

-

-// Forward-looking keypad definition

-// Won't work with applications that make ASCII assumptions

-// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-keypad_keys

-xkb_symbols "future_wang" {

-

-    include "keypad(core)"

-    include "keypad(futuremath)"

-    include "keypad(ossnumber_wang)"

-    include "kpdl(commaoss)"

-};

-

-

-// Keypad keys nobody changes

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-partial keypad_keys

-xkb_symbols "core" {

-

-    modifier_map Mod2 { Num_Lock };

-

-    key <NMLK> { [ Num_Lock, Pointer_EnableKeys ] };

-    key <KPEN> { [ KP_Enter                     ] };

-    key <KPEQ> { [ KP_Equal                     ] };

-};

-

-

-// Legacy keypad math area

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱─────┬─────┬─────┐

-// ┃Num  ┃ ₁   │ ₂   │ ₃   │ ₁ <XF86_Ungrab>

-// ┃Lock⇭┃ /   │ *   │ -   │ ₂ <XF86_ClearGrab>

-// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>

-//                   │ ₄   │ ₄ <XF86_Next_VMode>

-//                   │     │

-//                   ┤     │ 1 None

-//                   │     │ 2 Ctrl+Alt

-//                   │ +   │

-//                   ╆━━━━━┪

-partial keypad_keys

-xkb_symbols "legacymath" {

-

-    key.type[Group1]="CTRL+ALT" ;

-

-    key <KPDV> { [   KP_Divide,     XF86_Ungrab ] }; // / <XF86_Ungrab>

-    key <KPMU> { [ KP_Multiply,  XF86_ClearGrab ] }; // * <XF86_ClearGrab>

-    key <KPSU> { [ KP_Subtract, XF86_Prev_VMode ] }; // - <XF86_Prev_VMode>

-

-    key <KPAD> { [      KP_Add, XF86_Next_VMode ] }; // + <XF86_Next_VMode>

-

-};

-

-

-// Keypad math area with non-CS operators

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱─────┬─────┬─────┐

-// ┃Num  ┃ ∕ ₁ │ . ₂ │ − ₃ │ ₁ <XF86_Ungrab>

-// ┃Lock⇭┃ / ÷ │ * × │ - − │ ₂ <XF86_ClearGrab>

-// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>

-//                   │ + ₄ │ ₄ <XF86_Next_VMode>

-//                   │     │

-//                   ┤     │ 1 None

-//                   │     │ 2 Level3 ⇮

-//                   │ + + │ 3 Shift+Level3 ⇧⇮

-//                   ╆━━━━━┪ 4 Ctrl+Alt

-partial keypad_keys

-xkb_symbols "ossmath" {

-

-    key.type[Group1]="FOUR_LEVEL_X" ;

-

-    key <KPDV> { [   KP_Divide, 0x1002215, 0x10000F7,     XF86_Ungrab ] }; // / ∕ ÷     <XF86_Ungrab>

-    key <KPMU> { [ KP_Multiply, 0x10022C5, 0x10000D7,  XF86_ClearGrab ] }; // * ⋅ ×  <XF86_ClearGrab>

-    key <KPSU> { [ KP_Subtract, 0x1002212, 0x1002212, XF86_Prev_VMode ] }; // - − − <XF86_Prev_VMode>

-

-    key <KPAD> { [      KP_Add, 0x100002B, 0x100002B, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>

-

-};

-

-

-// Keypad math area with non-CS operators in first levels

-// As demanded by users not interested in legacy pre-unicode junk

-// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱─────┬─────┬─────┐

-// ┃Num  ┃ / ₁ │ * ₂ │ - ₃ │ ₁ <XF86_Ungrab>

-// ┃Lock⇭┃ ∕ ÷ │ . × │ − − │ ₂ <XF86_ClearGrab>

-// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>

-//                   │ + ₄ │ ₄ <XF86_Next_VMode>

-//                   │     │

-//                   ┤     │ 1 None

-//                   │     │ 2 Level3 ⇮

-//                   │ + + │ 3 Shift+Level3 ⇧⇮

-//                   ╆━━━━━┪ 4 Ctrl+Alt

-partial keypad_keys

-xkb_symbols "futuremath" {

-

-    key.type[Group1]="FOUR_LEVEL_X" ;

-

-    key <KPDV> { [ 0x1002215,   KP_Divide, 0x10000F7,     XF86_Ungrab ] }; // ∕ / ÷     <XF86_Ungrab>

-    key <KPMU> { [ 0x10022C5, KP_Multiply, 0x10000D7,  XF86_ClearGrab ] }; // ⋅ * ×  <XF86_ClearGrab>

-    key <KPSU> { [ 0x1002212, KP_Subtract, 0x1002212, XF86_Prev_VMode ] }; // − - − <XF86_Prev_VMode>

-

-    key <KPAD> { [ 0x100002B,      KP_Add, 0x100002B, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>

-};

-

-

-// Keypad math area with non-CS operators, restricted to latin9

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱─────┬─────┬─────┐

-// ┃Num  ┃ / ₁ │ · ₂ │ - ₃ │ ₁ <XF86_Ungrab>

-// ┃Lock⇭┃ / ÷ │ * × │ - - │ ₂ <XF86_ClearGrab>

-// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>

-//                   │ + ₄ │ ₄ <XF86_Next_VMode>

-//                   │     │

-//                   ┤     │ 1 None

-//                   │     │ 2 Level3 ⇮

-//                   │ + + │ 3 Shift+Level3 ⇧⇮

-//                   ╆━━━━━┪ 4 Ctrl+Alt

-partial keypad_keys

-xkb_symbols "ossmath_latin9" {

-

-    key.type[Group1]="FOUR_LEVEL_X";

-

-    key <KPDV> { [   KP_Divide,          slash, division,     XF86_Ungrab ] }; // / / ÷     <XF86_Ungrab>

-    key <KPMU> { [ KP_Multiply, periodcentered, multiply,  XF86_ClearGrab ] }; // * · ×  <XF86_ClearGrab>

-    key <KPSU> { [ KP_Subtract,          minus,    minus, XF86_Prev_VMode ] }; // - - - <XF86_Prev_VMode>

-

-    key <KPAD> { [      KP_Add,           plus,     plus, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>

-};

-

-

-// Legacy keypad number area

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱                   ⇱ Home

-// ┃Num  ┃                   ⇲ End

-// ┃Lock⇭┃                   ⇞ Page up

-// ┡━━━━━╃─────┼─────┼       ⇟ Page down

-// │ 7   │ 8   │ 9   │       ⇞ Page up

-// │ ⇱   │ ⇧   │ ⇞   │       ⎀ Insert

-// ├─────┼─────┼─────┤       ␥ Delete

-// │ 4   │ 5   │ 6   │       ⇦⇧⇨⇩ Directions

-// │ ⇦   │     │ ⇨   │

-// ├─────┼─────┼─────╆

-// │ 1   │ 2   │ 3   ┃

-// │ ⇲   │ ⇩   │ ⇟   ┃        1 None

-// ├─────┴─────┼─────┨        2 Num Lock ⇭

-// │ 0         │

-// │ ⎀         │

-// └───────────┴

-partial keypad_keys

-xkb_symbols "legacynumber" {

-

-    key.type[Group1]="KEYPAD" ;

-

-    key <KP7>  { [   KP_Home,       KP_7 ] }; //   <home> 7

-    key <KP8>  { [     KP_Up,       KP_8 ] }; //     <up> 8

-    key <KP9>  { [  KP_Prior,       KP_9 ] }; //  <prior> 9

- 

-    key <KP4>  { [   KP_Left,       KP_4 ] }; //   <left> 4

-    key <KP5>  { [  KP_Begin,       KP_5 ] }; //  <begin> 5

-    key <KP6>  { [  KP_Right,       KP_6 ] }; //  <right> 6

-

-    key <KP1>  { [    KP_End,       KP_1 ] }; //    <end> 1

-    key <KP2>  { [   KP_Down,       KP_2 ] }; //   <down> 2

-    key <KP3>  { [   KP_Next,       KP_3 ] }; //   <next> 3

-

-    key <KP0>  { [ KP_Insert,       KP_0 ] }; // <insert> 0

-};

-

-

-// Legacy Wang 725-3771-ae and 725-3771-uk keypad number area

-// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-// This is actually a three-level keypad, declared as four-level

-// to avoid defining a new type

-//

-// ┏━━━━━┱                   ⇱ Home

-// ┃Num  ┃                   ⇲ End

-// ┃Lock⇭┃                   ⇞ Page up

-// ┡━━━━━╃─────┼─────┼       ⇟ Page down

-// │ 7   │ 8   │ 9   │       ⇞ Page up

-// │ ⇱ < │ ⇧ > │ ⇞ ^ │       ⎀ Insert

-// ├─────┼─────┼─────┤       ␥ Delete

-// │ 4   │ 5   │ 6   │       ⇦⇧⇨⇩ Directions

-// │ ⇦ [ │   ] │ ⇨ $ │

-// ├─────┼─────┼─────╆

-// │ 1   │ 2   │ 3   ┃

-// │ ⇲ & │ ⇩ @ │ ⇟ # ┃       1 None

-// ├─────┴─────┼─────┨       2 Num Lock ⇭

-// │ 0         │             3 Level3 ⇮

-// │ ⎀         │

-// └───────────┴

-partial keypad_keys

-xkb_symbols "legacynumber_wang" {

-

-    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;

-

-    key <KP7>  { [   KP_Home,   KP_7,         less ] }; //   <home> 7 <

-    key <KP8>  { [     KP_Up,   KP_8,      greater ] }; //     <up> 8 >

-    key <KP9>  { [  KP_Prior,   KP_9,  asciicircum ] }; //  <prior> 9 ^

- 

-    key <KP4>  { [   KP_Left,   KP_4,  bracketleft ] }; //   <left> 4 [

-    key <KP5>  { [  KP_Begin,   KP_5, bracketright ] }; //  <begin> 5 ]

-    key <KP6>  { [  KP_Right,   KP_6,       dollar ] }; //  <right> 6 $

-

-    key <KP1>  { [    KP_End,   KP_1,    ampersand ] }; //    <end> 1 &

-    key <KP2>  { [   KP_Down,   KP_2,           at ] }; //   <down> 2 @

-    key <KP3>  { [   KP_Next,   KP_3,   numbersign ] }; //   <next> 3 #

-

-    key <KP0>  { [ KP_Insert,   KP_0,   apostrophe ] }; // <insert> 0 '

-};

-

-

-// Keypad number area with arrow symbols

-// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱                   ⇱ Home

-// ┃Num  ┃                   ⇲ End

-// ┃Lock⇭┃                   ⇞ Page up

-// ┡━━━━━╃─────┼─────┼       ⇟ Page down

-// │ 7 ⇖ │ 8 ⇑ │ 9 ⇗ │       ⇞ Page up

-// │ ⇱ ↖ │ ⇧ ↑ │ ⇞ ↗ │       ⎀ Insert

-// ├─────┼─────┼─────┤       ␥ Delete

-// │ 4 ⇐ │ 5 ⇔ │ 6 ⇗ │       ⇦⇧⇨⇩ Directions

-// │ ⇦ ← │   ↔ │ ⇨ ↗ │       ⍽ narrow no-break space

-// ├─────┼─────┼─────╆

-// │ 1 ⇙ │ 2 ⇓ │ 3 ⇘ ┃

-// │ ⇲ ↙ │ ⇩ ↓ │ ⇟ ↘ ┃       1 None

-// ├─────┴─────┼─────┨       2 Num Lock ⇭

-// │ 0       ⇕ │             3 Level3 ⇮

-// │ ⎀       ↕ │             4 Shift+Level3 ⇧⇮

-// └───────────┴

-partial keypad_keys

-xkb_symbols "ossnumber" {

-

-    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;

-

-    key <KP7>  { [   KP_Home,   KP_7, 0x1002196, 0x10021D6 ] }; //   <home> 7 ↖ ⇖

-    key <KP8>  { [     KP_Up,   KP_8, 0x1002191, 0x10021D1 ] }; //     <up> 8 ↑ ⇑

-    key <KP9>  { [  KP_Prior,   KP_9, 0x1002197, 0x10021D7 ] }; //  <prior> 9 ↗ ⇗

- 

-    key <KP4>  { [   KP_Left,   KP_4, 0x1002190, 0x10021D0 ] }; //   <left> 4 ← ⇐

-    key <KP5>  { [  KP_Begin,   KP_5, 0x1002194, 0x10021D4 ] }; //  <begin> 5 ↔ ⇔

-    key <KP6>  { [  KP_Right,   KP_6, 0x1002192, 0x10021D2 ] }; //  <right> 6 → ⇒

-

-    key <KP1>  { [    KP_End,   KP_1, 0x1002199, 0x10021D9 ] }; //    <end> 1 ↙ ⇙

-    key <KP2>  { [   KP_Down,   KP_2, 0x1002193, 0x10021D3 ] }; //   <down> 2 ↓ ⇓

-    key <KP3>  { [   KP_Next,   KP_3, 0x1002198, 0x10021D8 ] }; //   <next> 3 ↘ ⇘

-

-    key <KP0>  { [ KP_Insert,   KP_0, 0x1002195, 0x10021D5 ] }; // <insert> 0 ↕ ⇕

-};

-

-

-// Wang 725-3771-ae and 725-3771-uk keypad number area with additional arrow symbols

-// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>

-//

-// ┏━━━━━┱                   ⇱ Home

-// ┃Num  ┃                   ⇲ End

-// ┃Lock⇭┃                   ⇞ Page up

-// ┡━━━━━╃─────┼─────┼       ⇟ Page down

-// │ 7 ↖ │ 8 ↑ │ 9 ↗ │       ⇞ Page up

-// │ ⇱ < │ ⇧ > │ ⇞ ^ │       ⎀ Insert

-// ├─────┼─────┼─────┤       ␥ Delete

-// │ 4 ← │ 5 ↔ │ 6 → │       ⇦⇧⇨⇩ Directions

-// │ ⇦ [ │   ] │ ⇨ $ │       ⍽ narrow no-break space

-// ├─────┼─────┼─────╆

-// │ 1 ↙ │ 2 ↓ │ 3 ↘ ┃

-// │ ⇲ & │ ⇩ @ │ ⇟ # ┃       1 None

-// ├─────┴─────┼─────┨       2 Num Lock ⇭

-// │ 0       ↕ │             3 Level3 ⇮

-// │ ⎀       ' │             4 Shift+Level3 ⇧⇮

-// └───────────┴

-partial keypad_keys

-xkb_symbols "ossnumber_wang" {

-

-    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;

-

-    key <KP7>  { [   KP_Home,   KP_7,         less, 0x1002196 ] }; //   <home> 7 < ↖

-    key <KP8>  { [     KP_Up,   KP_8,      greater, 0x1002191 ] }; //     <up> 8 > ↑

-    key <KP9>  { [  KP_Prior,   KP_9,  asciicircum, 0x1002197 ] }; //  <prior> 9 ^ ↗

- 

-    key <KP4>  { [   KP_Left,   KP_4,  bracketleft, 0x1002190 ] }; //   <left> 4 [ ←

-    key <KP5>  { [  KP_Begin,   KP_5, bracketright, 0x1002194 ] }; //  <begin> 5 ] ↔

-    key <KP6>  { [  KP_Right,   KP_6,       dollar, 0x1002192 ] }; //  <right> 6 $ →

-

-    key <KP1>  { [    KP_End,   KP_1,    ampersand, 0x1002199 ] }; //    <end> 1 & ↙

-    key <KP2>  { [   KP_Down,   KP_2,           at, 0x1002193 ] }; //   <down> 2 @ ↓

-    key <KP3>  { [   KP_Next,   KP_3,   numbersign, 0x1002198 ] }; //   <next> 3 # ↘

-

-    key <KP0>  { [ KP_Insert,   KP_0,   apostrophe, 0x1002195 ] }; // <insert> 0 ' ↕

-};

-

-// Standard base "pc" layout only contains cursor keys, and then gets

-// augmented with the digits later. If you define your own layout for

-// the numpad you can inherit the cursors, but you'll have to define

-// the digits yourself. This module can be included in the rules to

-// define math operators; these are the variants used in computer

-// languages that are based on ASCII. NoSymbol doesn't mean that

-// nothing is bound to the key but that no assignment is done here.

-// srvr_ctrl(stdkeypad) and keypad(x11) declare the operator keys to

-// be of type CTRL+ALT in order to assign server control events to

-// them, but it uses the second level which is overwritten if we have

-// more than one definition (shift state) for the key. Instead, here

-// the commands are put at the fourth level.

-partial keypad_keys

-xkb_symbols "ops" {

-    key <KPDV> { [ NoSymbol,  slash,     NoSymbol,  XF86_Ungrab     ] };

-    key <KPMU> { [ NoSymbol,  asterisk,  NoSymbol,  XF86_ClearGrab  ] };

-    key <KPSU> { [ NoSymbol,  minus,     NoSymbol,  XF86_Prev_VMode ] };

-    key <KPAD> { [ NoSymbol,  plus,      NoSymbol,  XF86_Next_VMode ] };

-    key <KPEQ> { [ NoSymbol,  equal      ] };

-};

-

-// Hexadecimal Numpad, by Roland Kaufmann <rlndkfmn at gmail dot com>

-// License: BSD (also covers variant with ATM digit order)

-// Third-level gives the letters used in hexadecimal numbers, or

-// columns in small spreadsheets. As a bonus, having 'e' available at

-// the center of the keyboard makes it easy to enter floating point

-// numbers in scientific notation.

-// Equal is added to start formulas (most numpads on PCs don't have

-// their own equal key), comma as a list separator (as most

-// programming languages wants period as a decimal separator) and

-// colon to enter times and ranges. Someone also may want to represent

-// multiplication and division in prose using x and colon.

-// Two first levels are specified as NoSymbol to not override any

-// previous specification. Combine this with another keypad specifier,

-// e.g. "legacy".

-partial keypad_keys

-xkb_symbols "hex" {

-    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;

-

-    //             None       NumLock      AltGr

-    // symbol row

-    key <KPDV> { [ NoSymbol,  NoSymbol,  parenleft  ] };

-    key <KPMU> { [ NoSymbol,  NoSymbol,  parenright ] };

-    key <KPSU> { [ NoSymbol,  NoSymbol,  dollar     ] };

-

-    // upper row

-    key <KP7>  { [ NoSymbol,  NoSymbol,  a          ] };

-    key <KP8>  { [ NoSymbol,  NoSymbol,  b          ] };

-    key <KP9>  { [ NoSymbol,  NoSymbol,  c          ] };

- 

-    // home row

-    key <KP4>  { [ NoSymbol,  NoSymbol,  d          ] };

-    key <KP5>  { [ NoSymbol,  NoSymbol,  e          ] };

-    key <KP6>  { [ NoSymbol,  NoSymbol,  f          ] };

-    key <KPAD> { [ NoSymbol,  NoSymbol,  comma      ] };

-

-    // lower row

-    key <KP1>  { [ NoSymbol,  NoSymbol,  equal      ] };

-    key <KP2>  { [ NoSymbol,  NoSymbol,  x          ] };

-    key <KP3>  { [ NoSymbol,  NoSymbol,  colon      ] };

-

-    // decimal row

-    key <KP0>  { [ NoSymbol,  NoSymbol,  backslash  ] };

-};

-

-// Main numbers follows the traditions from ATMs and phones with

-// numbers increasing downwards to the right. (It is easier to

-// change the keyboard layout than to reprogram your local ATM;

-// also cell-phones are becoming more common while calculators are

-// becoming more rare).

-// First level is left unspecified, so it may be combined with another

-// layout, e.g. "legacy".

-partial keypad_keys

-xkb_symbols "atm" {

-    // upper row

-    key <KP7>  { [ NoSymbol,  KP_1 ] };

-    key <KP8>  { [ NoSymbol,  KP_2 ] };

-    key <KP9>  { [ NoSymbol,  KP_3 ] };

-

-    // lower row

-    key <KP1>  { [ NoSymbol,  KP_7 ] };

-    key <KP2>  { [ NoSymbol,  KP_8 ] };

-    key <KP3>  { [ NoSymbol,  KP_9 ] };

-};

-

-

-partial default modifier_keys

-xkb_symbols "pointerkeys" {

-    key <NMLK> {	[ Num_Lock,	Pointer_EnableKeys 	]	};

-};

-

-// Only numbers, operators and decimal separator,

-// as seen on keypad overlay on Japanese keyboard.

-// ┌─┬─┬─┬─┐

-// │7│8│9│*│

-// ├─┼─┼─┼─┤

-// │4│5│6│-│

-// ├─┼─┼─┼─┤

-// │1│2│3│+│

-// ├─┼─┼─┼─┤

-// │0│ │·│/│

-// └─┴─┴─┴─┘

-partial keypad_keys

-xkb_symbols "numoperdecsep" {

-    key  <KO7> {	[  KP_7	]	};

-    key  <KO8> {	[  KP_8	]	};

-    key  <KO9> {	[  KP_9	]	};

-// ClsGrb kills whichever client has a grab in effect

-    key <KOMU> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Multiply,	XF86_ClearGrab ]

-    };

-

-    key  <KO4> {	[  KP_4	]	};

-    key  <KO5> {	[  KP_5	]	};

-    key  <KO6> {	[  KP_6	]	};

-// -VMode switches to the previous video mode

-    key <KOSU> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Subtract,	XF86_Prev_VMode ]

-    };

-

-    key  <KO1> {	[  KP_1	]	};

-    key  <KO2> {	[  KP_2	]	};

-    key  <KO3> {	[  KP_3	]	};

-// +VMode switches to the next video mode

-    key <KOAD> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Add,	XF86_Next_VMode ]

-    };

-

-    key  <KO0> {	[  KP_0	]	};

-    key <KODL> {	[ KP_Decimal ]	};

-// Ungrab cancels server/keyboard/pointer grabs

-    key <KODV> {

-        type="CTRL+ALT",

-        symbols[Group1]= [ KP_Divide,	XF86_Ungrab ]

-    };

-};

+partial hidden keypad_keys
+xkb_symbols "overlay" {
+    include "keypad(overlay1)"
+};
+
+partial hidden keypad_keys
+xkb_symbols "overlay1" {
+
+    // Begin "Keypad" section
+
+    key  <KP7> {	[  KP_Home	],	overlay1=<KO7>	};
+    key  <KP8> {	[  KP_Up	],	overlay1=<KO8>	};
+    key  <KP9> {	[  KP_Prior	],	overlay1=<KO9>	};
+
+    key  <KP4> {	[  KP_Left	],	overlay1=<KO4>	};
+    key  <KP5> {	[  KP_Begin	],	overlay1=<KO5>	};
+    key  <KP6> {	[  KP_Right	],	overlay1=<KO6>	};
+
+    key  <KP1> {	[  KP_End	],	overlay1=<KO1>	};
+    key  <KP2> {	[  KP_Down	],	overlay1=<KO2>	};
+    key  <KP3> {	[  KP_Next	],	overlay1=<KO3>	};
+
+    key  <KP0> {	[  KP_Insert	],	overlay1=<KO0>	};
+    key <KPDL> {  	[  KP_Delete	],	overlay1=<KODL>	};
+
+    key  <KO7> {	[  KP_7	]	};
+    key  <KO8> {	[  KP_8	]	};
+    key  <KO9> {	[  KP_9	]	};
+
+    key  <KO4> {	[  KP_4	]	};
+    key  <KO5> {	[  KP_5	]	};
+    key  <KO6> {	[  KP_6	]	};
+
+    key  <KO1> {	[  KP_1	]	};
+    key  <KO2> {	[  KP_2	]	};
+    key  <KO3> {	[  KP_3	]	};
+
+    key  <KO0> {	[  KP_0	]	};
+    key <KODL> {  	[  KP_Decimal ]	};
+
+    // End "Keypad" section
+};
+
+partial hidden keypad_keys
+xkb_symbols "overlay2" {
+
+    // Begin "Keypad" section
+
+    key  <KP7> {	[  KP_Home	],	overlay2=<KO7>	};
+    key  <KP8> {	[  KP_Up	],	overlay2=<KO8>	};
+    key  <KP9> {	[  KP_Prior	],	overlay2=<KO9>	};
+
+    key  <KP4> {	[  KP_Left	],	overlay2=<KO4>	};
+    key  <KP5> {	[  KP_Begin	],	overlay2=<KO5>	};
+    key  <KP6> {	[  KP_Right	],	overlay2=<KO6>	};
+
+    key  <KP1> {	[  KP_End	],	overlay2=<KO1>	};
+    key  <KP2> {	[  KP_Down	],	overlay2=<KO2>	};
+    key  <KP3> {	[  KP_Next	],	overlay2=<KO3>	};
+
+    key  <KP0> {	[  KP_Insert	],	overlay2=<KO0>	};
+    key <KPDL> {  	[  KP_Delete	],	overlay2=<KODL>	};
+
+    key  <KO7> {	[  KP_7	]	};
+    key  <KO8> {	[  KP_8	]	};
+    key  <KO9> {	[  KP_9	]	};
+
+    key  <KO4> {	[  KP_4	]	};
+    key  <KO5> {	[  KP_5	]	};
+    key  <KO6> {	[  KP_6	]	};
+
+    key  <KO1> {	[  KP_1	]	};
+    key  <KO2> {	[  KP_2	]	};
+    key  <KO3> {	[  KP_3	]	};
+
+    key  <KO0> {	[  KP_0	]	};
+    key <KODL> {  	[  KP_Decimal ]	};
+
+    // End "Keypad" section
+};
+
+partial hidden default keypad_keys
+xkb_symbols "x11" {
+// Ungrab cancels server/keyboard/pointer grabs
+    key <KPDV> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Divide, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Ungrab ]
+    };
+
+// ClsGrb kills whichever client has a grab in effect
+    key <KPMU> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Multiply,	VoidSymbol, VoidSymbol, VoidSymbol, XF86_ClearGrab ]
+    };
+
+// -VMode switches to the previous video mode
+    key <KPSU> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Subtract, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Prev_VMode ]
+    };
+
+    key  <KP7> {	[  KP_Home,	KP_7	]	};
+    key  <KP8> {	[  KP_Up,	KP_8	]	};
+    key  <KP9> {	[  KP_Prior,	KP_9	]	};
+
+// +VMode switches to the next video mode
+    key <KPAD> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Add, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Next_VMode ]
+    };
+
+    key  <KP4> {	[  KP_Left,	KP_4	]	};
+    key  <KP5> {	[  KP_Begin,	KP_5	]	};
+    key  <KP6> {	[  KP_Right,	KP_6	]	};
+
+    key  <KP1> {	[  KP_End,	KP_1	]	};
+    key  <KP2> {	[  KP_Down,	KP_2	]	};
+    key  <KP3> {	[  KP_Next,	KP_3	]	};
+    key <KPEN> {	[  	KP_Enter	]	};
+    key <KPEQ> {	[  	KP_Equal	]	};
+
+    key  <KP0> {	[  KP_Insert,	KP_0	]	};
+    key <KPDL> {  	[  KP_Delete,	KP_Decimal ]	};
+    key <KPPT> {  	[  KP_Decimal,	KP_Decimal ]	};
+};
+
+
+// Legacy PC keypad definition
+// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "legacy" {
+
+    include "keypad(core)"
+    include "keypad(legacymath)"
+    include "keypad(legacynumber)"
+    include "kpdl(dot)"
+};
+
+
+// Legacy Wang 725-3771-ae and 725-3771-uk keypad definition
+// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "legacy_wang" {
+
+    include "keypad(core)"
+    include "keypad(legacymath)"
+    include "keypad(legacynumber_wang)"
+    include "kpdl(dot)"
+};
+
+
+// Complete new keypad definition
+// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "oss" {
+
+    include "keypad(core)"
+    include "keypad(ossmath)"
+    include "keypad(ossnumber)"
+    include "kpdl(dotoss)"
+};
+
+
+// Latin9 restriction of new keypad definition
+// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "oss_latin9" {
+
+    include "keypad(core)"
+    include "keypad(ossmath_latin9)"
+    include "keypad(legacynumber)"
+    include "kpdl(dotoss_latin9)"
+};
+
+
+// Wang 725-3771-ae and 725-3771-uk keypad variant of oss keypad
+// Copyright © 2006-2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "oss_wang" {
+
+    include "keypad(core)"
+    include "keypad(ossmath)"
+    include "keypad(ossnumber_wang)"
+    include "kpdl(dotoss)"
+};
+
+
+// Forward-looking keypad definition
+// Won't work with applications that make ASCII assumptions
+// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "future" {
+
+    include "keypad(core)"
+    include "keypad(futuremath)"
+    include "keypad(ossnumber)"
+    include "kpdl(commaoss)"
+};
+
+
+// Forward-looking keypad definition
+// Won't work with applications that make ASCII assumptions
+// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+keypad_keys
+xkb_symbols "future_wang" {
+
+    include "keypad(core)"
+    include "keypad(futuremath)"
+    include "keypad(ossnumber_wang)"
+    include "kpdl(commaoss)"
+};
+
+
+// Keypad keys nobody changes
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+partial keypad_keys
+xkb_symbols "core" {
+
+    modifier_map Mod2 { Num_Lock };
+
+    key <NMLK> { [ Num_Lock, Pointer_EnableKeys ] };
+    key <KPEN> { [ KP_Enter                     ] };
+    key <KPEQ> { [ KP_Equal                     ] };
+};
+
+
+// Legacy keypad math area
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱─────┬─────┬─────┐
+// ┃Num  ┃ ₁   │ ₂   │ ₃   │ ₁ <XF86_Ungrab>
+// ┃Lock⇭┃ /   │ *   │ -   │ ₂ <XF86_ClearGrab>
+// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>
+//                   │ ₄   │ ₄ <XF86_Next_VMode>
+//                   │     │
+//                   ┤     │ 1 None
+//                   │     │ 2 Ctrl+Alt
+//                   │ +   │
+//                   ╆━━━━━┪
+partial keypad_keys
+xkb_symbols "legacymath" {
+
+    key.type[Group1]="CTRL+ALT" ;
+
+    key <KPDV> { [   KP_Divide, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Ungrab ] }; // / <XF86_Ungrab>
+    key <KPMU> { [ KP_Multiply, VoidSymbol, VoidSymbol, VoidSymbol, XF86_ClearGrab ] }; // * <XF86_ClearGrab>
+    key <KPSU> { [ KP_Subtract, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Prev_VMode ] }; // - <XF86_Prev_VMode>
+
+    key <KPAD> { [      KP_Add, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Next_VMode ] }; // + <XF86_Next_VMode>
+
+};
+
+
+// Keypad math area with non-CS operators
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱─────┬─────┬─────┐
+// ┃Num  ┃ ∕ ₁ │ . ₂ │ − ₃ │ ₁ <XF86_Ungrab>
+// ┃Lock⇭┃ / ÷ │ * × │ - − │ ₂ <XF86_ClearGrab>
+// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>
+//                   │ + ₄ │ ₄ <XF86_Next_VMode>
+//                   │     │
+//                   ┤     │ 1 None
+//                   │     │ 2 Level3 ⇮
+//                   │ + + │ 3 Shift+Level3 ⇧⇮
+//                   ╆━━━━━┪ 4 Ctrl+Alt
+partial keypad_keys
+xkb_symbols "ossmath" {
+
+    key.type[Group1]="FOUR_LEVEL_X" ;
+
+    key <KPDV> { [   KP_Divide, 0x1002215, 0x10000F7,     XF86_Ungrab ] }; // / ∕ ÷     <XF86_Ungrab>
+    key <KPMU> { [ KP_Multiply, 0x10022C5, 0x10000D7,  XF86_ClearGrab ] }; // * ⋅ ×  <XF86_ClearGrab>
+    key <KPSU> { [ KP_Subtract, 0x1002212, 0x1002212, XF86_Prev_VMode ] }; // - − − <XF86_Prev_VMode>
+
+    key <KPAD> { [      KP_Add, 0x100002B, 0x100002B, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>
+
+};
+
+
+// Keypad math area with non-CS operators in first levels
+// As demanded by users not interested in legacy pre-unicode junk
+// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱─────┬─────┬─────┐
+// ┃Num  ┃ / ₁ │ * ₂ │ - ₃ │ ₁ <XF86_Ungrab>
+// ┃Lock⇭┃ ∕ ÷ │ . × │ − − │ ₂ <XF86_ClearGrab>
+// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>
+//                   │ + ₄ │ ₄ <XF86_Next_VMode>
+//                   │     │
+//                   ┤     │ 1 None
+//                   │     │ 2 Level3 ⇮
+//                   │ + + │ 3 Shift+Level3 ⇧⇮
+//                   ╆━━━━━┪ 4 Ctrl+Alt
+partial keypad_keys
+xkb_symbols "futuremath" {
+
+    key.type[Group1]="FOUR_LEVEL_X" ;
+
+    key <KPDV> { [ 0x1002215,   KP_Divide, 0x10000F7,     XF86_Ungrab ] }; // ∕ / ÷     <XF86_Ungrab>
+    key <KPMU> { [ 0x10022C5, KP_Multiply, 0x10000D7,  XF86_ClearGrab ] }; // ⋅ * ×  <XF86_ClearGrab>
+    key <KPSU> { [ 0x1002212, KP_Subtract, 0x1002212, XF86_Prev_VMode ] }; // − - − <XF86_Prev_VMode>
+
+    key <KPAD> { [ 0x100002B,      KP_Add, 0x100002B, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>
+};
+
+
+// Keypad math area with non-CS operators, restricted to latin9
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱─────┬─────┬─────┐
+// ┃Num  ┃ / ₁ │ · ₂ │ - ₃ │ ₁ <XF86_Ungrab>
+// ┃Lock⇭┃ / ÷ │ * × │ - - │ ₂ <XF86_ClearGrab>
+// ┡━━━━━╃─────┼─────┼─────┤ ₃ <XF86_Prev_VMode>
+//                   │ + ₄ │ ₄ <XF86_Next_VMode>
+//                   │     │
+//                   ┤     │ 1 None
+//                   │     │ 2 Level3 ⇮
+//                   │ + + │ 3 Shift+Level3 ⇧⇮
+//                   ╆━━━━━┪ 4 Ctrl+Alt
+partial keypad_keys
+xkb_symbols "ossmath_latin9" {
+
+    key.type[Group1]="FOUR_LEVEL_X";
+
+    key <KPDV> { [   KP_Divide,          slash, division,     XF86_Ungrab ] }; // / / ÷     <XF86_Ungrab>
+    key <KPMU> { [ KP_Multiply, periodcentered, multiply,  XF86_ClearGrab ] }; // * · ×  <XF86_ClearGrab>
+    key <KPSU> { [ KP_Subtract,          minus,    minus, XF86_Prev_VMode ] }; // - - - <XF86_Prev_VMode>
+
+    key <KPAD> { [      KP_Add,           plus,     plus, XF86_Next_VMode ] }; // + + + <XF86_Next_VMode>
+};
+
+
+// Legacy keypad number area
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱                   ⇱ Home
+// ┃Num  ┃                   ⇲ End
+// ┃Lock⇭┃                   ⇞ Page up
+// ┡━━━━━╃─────┼─────┼       ⇟ Page down
+// │ 7   │ 8   │ 9   │       ⇞ Page up
+// │ ⇱   │ ⇧   │ ⇞   │       ⎀ Insert
+// ├─────┼─────┼─────┤       ␥ Delete
+// │ 4   │ 5   │ 6   │       ⇦⇧⇨⇩ Directions
+// │ ⇦   │     │ ⇨   │
+// ├─────┼─────┼─────╆
+// │ 1   │ 2   │ 3   ┃
+// │ ⇲   │ ⇩   │ ⇟   ┃        1 None
+// ├─────┴─────┼─────┨        2 Num Lock ⇭
+// │ 0         │
+// │ ⎀         │
+// └───────────┴
+partial keypad_keys
+xkb_symbols "legacynumber" {
+
+    key.type[Group1]="KEYPAD" ;
+
+    key <KP7>  { [   KP_Home,       KP_7 ] }; //   <home> 7
+    key <KP8>  { [     KP_Up,       KP_8 ] }; //     <up> 8
+    key <KP9>  { [  KP_Prior,       KP_9 ] }; //  <prior> 9
+ 
+    key <KP4>  { [   KP_Left,       KP_4 ] }; //   <left> 4
+    key <KP5>  { [  KP_Begin,       KP_5 ] }; //  <begin> 5
+    key <KP6>  { [  KP_Right,       KP_6 ] }; //  <right> 6
+
+    key <KP1>  { [    KP_End,       KP_1 ] }; //    <end> 1
+    key <KP2>  { [   KP_Down,       KP_2 ] }; //   <down> 2
+    key <KP3>  { [   KP_Next,       KP_3 ] }; //   <next> 3
+
+    key <KP0>  { [ KP_Insert,       KP_0 ] }; // <insert> 0
+};
+
+
+// Legacy Wang 725-3771-ae and 725-3771-uk keypad number area
+// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+// This is actually a three-level keypad, declared as four-level
+// to avoid defining a new type
+//
+// ┏━━━━━┱                   ⇱ Home
+// ┃Num  ┃                   ⇲ End
+// ┃Lock⇭┃                   ⇞ Page up
+// ┡━━━━━╃─────┼─────┼       ⇟ Page down
+// │ 7   │ 8   │ 9   │       ⇞ Page up
+// │ ⇱ < │ ⇧ > │ ⇞ ^ │       ⎀ Insert
+// ├─────┼─────┼─────┤       ␥ Delete
+// │ 4   │ 5   │ 6   │       ⇦⇧⇨⇩ Directions
+// │ ⇦ [ │   ] │ ⇨ $ │
+// ├─────┼─────┼─────╆
+// │ 1   │ 2   │ 3   ┃
+// │ ⇲ & │ ⇩ @ │ ⇟ # ┃       1 None
+// ├─────┴─────┼─────┨       2 Num Lock ⇭
+// │ 0         │             3 Level3 ⇮
+// │ ⎀         │
+// └───────────┴
+partial keypad_keys
+xkb_symbols "legacynumber_wang" {
+
+    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;
+
+    key <KP7>  { [   KP_Home,   KP_7,         less ] }; //   <home> 7 <
+    key <KP8>  { [     KP_Up,   KP_8,      greater ] }; //     <up> 8 >
+    key <KP9>  { [  KP_Prior,   KP_9,  asciicircum ] }; //  <prior> 9 ^
+ 
+    key <KP4>  { [   KP_Left,   KP_4,  bracketleft ] }; //   <left> 4 [
+    key <KP5>  { [  KP_Begin,   KP_5, bracketright ] }; //  <begin> 5 ]
+    key <KP6>  { [  KP_Right,   KP_6,       dollar ] }; //  <right> 6 $
+
+    key <KP1>  { [    KP_End,   KP_1,    ampersand ] }; //    <end> 1 &
+    key <KP2>  { [   KP_Down,   KP_2,           at ] }; //   <down> 2 @
+    key <KP3>  { [   KP_Next,   KP_3,   numbersign ] }; //   <next> 3 #
+
+    key <KP0>  { [ KP_Insert,   KP_0,   apostrophe ] }; // <insert> 0 '
+};
+
+
+// Keypad number area with arrow symbols
+// Copyright © 2006 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱                   ⇱ Home
+// ┃Num  ┃                   ⇲ End
+// ┃Lock⇭┃                   ⇞ Page up
+// ┡━━━━━╃─────┼─────┼       ⇟ Page down
+// │ 7 ⇖ │ 8 ⇑ │ 9 ⇗ │       ⇞ Page up
+// │ ⇱ ↖ │ ⇧ ↑ │ ⇞ ↗ │       ⎀ Insert
+// ├─────┼─────┼─────┤       ␥ Delete
+// │ 4 ⇐ │ 5 ⇔ │ 6 ⇗ │       ⇦⇧⇨⇩ Directions
+// │ ⇦ ← │   ↔ │ ⇨ ↗ │       ⍽ narrow no-break space
+// ├─────┼─────┼─────╆
+// │ 1 ⇙ │ 2 ⇓ │ 3 ⇘ ┃
+// │ ⇲ ↙ │ ⇩ ↓ │ ⇟ ↘ ┃       1 None
+// ├─────┴─────┼─────┨       2 Num Lock ⇭
+// │ 0       ⇕ │             3 Level3 ⇮
+// │ ⎀       ↕ │             4 Shift+Level3 ⇧⇮
+// └───────────┴
+partial keypad_keys
+xkb_symbols "ossnumber" {
+
+    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;
+
+    key <KP7>  { [   KP_Home,   KP_7, 0x1002196, 0x10021D6 ] }; //   <home> 7 ↖ ⇖
+    key <KP8>  { [     KP_Up,   KP_8, 0x1002191, 0x10021D1 ] }; //     <up> 8 ↑ ⇑
+    key <KP9>  { [  KP_Prior,   KP_9, 0x1002197, 0x10021D7 ] }; //  <prior> 9 ↗ ⇗
+ 
+    key <KP4>  { [   KP_Left,   KP_4, 0x1002190, 0x10021D0 ] }; //   <left> 4 ← ⇐
+    key <KP5>  { [  KP_Begin,   KP_5, 0x1002194, 0x10021D4 ] }; //  <begin> 5 ↔ ⇔
+    key <KP6>  { [  KP_Right,   KP_6, 0x1002192, 0x10021D2 ] }; //  <right> 6 → ⇒
+
+    key <KP1>  { [    KP_End,   KP_1, 0x1002199, 0x10021D9 ] }; //    <end> 1 ↙ ⇙
+    key <KP2>  { [   KP_Down,   KP_2, 0x1002193, 0x10021D3 ] }; //   <down> 2 ↓ ⇓
+    key <KP3>  { [   KP_Next,   KP_3, 0x1002198, 0x10021D8 ] }; //   <next> 3 ↘ ⇘
+
+    key <KP0>  { [ KP_Insert,   KP_0, 0x1002195, 0x10021D5 ] }; // <insert> 0 ↕ ⇕
+};
+
+
+// Wang 725-3771-ae and 725-3771-uk keypad number area with additional arrow symbols
+// Copyright © 2007 Nicolas Mailhot <nicolas.mailhot @ laposte.net>
+//
+// ┏━━━━━┱                   ⇱ Home
+// ┃Num  ┃                   ⇲ End
+// ┃Lock⇭┃                   ⇞ Page up
+// ┡━━━━━╃─────┼─────┼       ⇟ Page down
+// │ 7 ↖ │ 8 ↑ │ 9 ↗ │       ⇞ Page up
+// │ ⇱ < │ ⇧ > │ ⇞ ^ │       ⎀ Insert
+// ├─────┼─────┼─────┤       ␥ Delete
+// │ 4 ← │ 5 ↔ │ 6 → │       ⇦⇧⇨⇩ Directions
+// │ ⇦ [ │   ] │ ⇨ $ │       ⍽ narrow no-break space
+// ├─────┼─────┼─────╆
+// │ 1 ↙ │ 2 ↓ │ 3 ↘ ┃
+// │ ⇲ & │ ⇩ @ │ ⇟ # ┃       1 None
+// ├─────┴─────┼─────┨       2 Num Lock ⇭
+// │ 0       ↕ │             3 Level3 ⇮
+// │ ⎀       ' │             4 Shift+Level3 ⇧⇮
+// └───────────┴
+partial keypad_keys
+xkb_symbols "ossnumber_wang" {
+
+    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;
+
+    key <KP7>  { [   KP_Home,   KP_7,         less, 0x1002196 ] }; //   <home> 7 < ↖
+    key <KP8>  { [     KP_Up,   KP_8,      greater, 0x1002191 ] }; //     <up> 8 > ↑
+    key <KP9>  { [  KP_Prior,   KP_9,  asciicircum, 0x1002197 ] }; //  <prior> 9 ^ ↗
+ 
+    key <KP4>  { [   KP_Left,   KP_4,  bracketleft, 0x1002190 ] }; //   <left> 4 [ ←
+    key <KP5>  { [  KP_Begin,   KP_5, bracketright, 0x1002194 ] }; //  <begin> 5 ] ↔
+    key <KP6>  { [  KP_Right,   KP_6,       dollar, 0x1002192 ] }; //  <right> 6 $ →
+
+    key <KP1>  { [    KP_End,   KP_1,    ampersand, 0x1002199 ] }; //    <end> 1 & ↙
+    key <KP2>  { [   KP_Down,   KP_2,           at, 0x1002193 ] }; //   <down> 2 @ ↓
+    key <KP3>  { [   KP_Next,   KP_3,   numbersign, 0x1002198 ] }; //   <next> 3 # ↘
+
+    key <KP0>  { [ KP_Insert,   KP_0,   apostrophe, 0x1002195 ] }; // <insert> 0 ' ↕
+};
+
+// Standard base "pc" layout only contains cursor keys, and then gets
+// augmented with the digits later. If you define your own layout for
+// the numpad you can inherit the cursors, but you'll have to define
+// the digits yourself. This module can be included in the rules to
+// define math operators; these are the variants used in computer
+// languages that are based on ASCII. NoSymbol doesn't mean that
+// nothing is bound to the key but that no assignment is done here.
+// srvr_ctrl(stdkeypad) and keypad(x11) declare the operator keys to
+// be of type CTRL+ALT in order to assign server control events to
+// them, but it uses the second level which is overwritten if we have
+// more than one definition (shift state) for the key. Instead, here
+// the commands are put at the fourth level.
+partial keypad_keys
+xkb_symbols "ops" {
+    key <KPDV> { [ NoSymbol,  slash,     NoSymbol,  XF86_Ungrab     ] };
+    key <KPMU> { [ NoSymbol,  asterisk,  NoSymbol,  XF86_ClearGrab  ] };
+    key <KPSU> { [ NoSymbol,  minus,     NoSymbol,  XF86_Prev_VMode ] };
+    key <KPAD> { [ NoSymbol,  plus,      NoSymbol,  XF86_Next_VMode ] };
+    key <KPEQ> { [ NoSymbol,  equal      ] };
+};
+
+// Hexadecimal Numpad, by Roland Kaufmann <rlndkfmn at gmail dot com>
+// License: BSD (also covers variant with ATM digit order)
+// Third-level gives the letters used in hexadecimal numbers, or
+// columns in small spreadsheets. As a bonus, having 'e' available at
+// the center of the keyboard makes it easy to enter floating point
+// numbers in scientific notation.
+// Equal is added to start formulas (most numpads on PCs don't have
+// their own equal key), comma as a list separator (as most
+// programming languages wants period as a decimal separator) and
+// colon to enter times and ranges. Someone also may want to represent
+// multiplication and division in prose using x and colon.
+// Two first levels are specified as NoSymbol to not override any
+// previous specification. Combine this with another keypad specifier,
+// e.g. "legacy".
+partial keypad_keys
+xkb_symbols "hex" {
+    key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ;
+
+    //             None       NumLock      AltGr
+    // symbol row
+    key <KPDV> { [ NoSymbol,  NoSymbol,  parenleft  ] };
+    key <KPMU> { [ NoSymbol,  NoSymbol,  parenright ] };
+    key <KPSU> { [ NoSymbol,  NoSymbol,  dollar     ] };
+
+    // upper row
+    key <KP7>  { [ NoSymbol,  NoSymbol,  a          ] };
+    key <KP8>  { [ NoSymbol,  NoSymbol,  b          ] };
+    key <KP9>  { [ NoSymbol,  NoSymbol,  c          ] };
+ 
+    // home row
+    key <KP4>  { [ NoSymbol,  NoSymbol,  d          ] };
+    key <KP5>  { [ NoSymbol,  NoSymbol,  e          ] };
+    key <KP6>  { [ NoSymbol,  NoSymbol,  f          ] };
+    key <KPAD> { [ NoSymbol,  NoSymbol,  comma      ] };
+
+    // lower row
+    key <KP1>  { [ NoSymbol,  NoSymbol,  equal      ] };
+    key <KP2>  { [ NoSymbol,  NoSymbol,  x          ] };
+    key <KP3>  { [ NoSymbol,  NoSymbol,  colon      ] };
+
+    // decimal row
+    key <KP0>  { [ NoSymbol,  NoSymbol,  backslash  ] };
+};
+
+// Main numbers follows the traditions from ATMs and phones with
+// numbers increasing downwards to the right. (It is easier to
+// change the keyboard layout than to reprogram your local ATM;
+// also cell-phones are becoming more common while calculators are
+// becoming more rare).
+// First level is left unspecified, so it may be combined with another
+// layout, e.g. "legacy".
+partial keypad_keys
+xkb_symbols "atm" {
+    // upper row
+    key <KP7>  { [ NoSymbol,  KP_1 ] };
+    key <KP8>  { [ NoSymbol,  KP_2 ] };
+    key <KP9>  { [ NoSymbol,  KP_3 ] };
+
+    // lower row
+    key <KP1>  { [ NoSymbol,  KP_7 ] };
+    key <KP2>  { [ NoSymbol,  KP_8 ] };
+    key <KP3>  { [ NoSymbol,  KP_9 ] };
+};
+
+
+partial default modifier_keys
+xkb_symbols "pointerkeys" {
+    key <NMLK> {	[ Num_Lock,	Pointer_EnableKeys 	]	};
+};
+
+// Only numbers, operators and decimal separator,
+// as seen on keypad overlay on Japanese keyboard.
+// ┌─┬─┬─┬─┐
+// │7│8│9│*│
+// ├─┼─┼─┼─┤
+// │4│5│6│-│
+// ├─┼─┼─┼─┤
+// │1│2│3│+│
+// ├─┼─┼─┼─┤
+// │0│ │·│/│
+// └─┴─┴─┴─┘
+partial keypad_keys
+xkb_symbols "numoperdecsep" {
+    key  <KO7> {	[  KP_7	]	};
+    key  <KO8> {	[  KP_8	]	};
+    key  <KO9> {	[  KP_9	]	};
+// ClsGrb kills whichever client has a grab in effect
+    key <KOMU> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Multiply, VoidSymbol, VoidSymbol, VoidSymbol, XF86_ClearGrab ]
+    };
+
+    key  <KO4> {	[  KP_4	]	};
+    key  <KO5> {	[  KP_5	]	};
+    key  <KO6> {	[  KP_6	]	};
+// -VMode switches to the previous video mode
+    key <KOSU> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Subtract, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Prev_VMode ]
+    };
+
+    key  <KO1> {	[  KP_1	]	};
+    key  <KO2> {	[  KP_2	]	};
+    key  <KO3> {	[  KP_3	]	};
+// +VMode switches to the next video mode
+    key <KOAD> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Add, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Next_VMode ]
+    };
+
+    key  <KO0> {	[  KP_0	]	};
+    key <KODL> {	[ KP_Decimal ]	};
+// Ungrab cancels server/keyboard/pointer grabs
+    key <KODV> {
+        type="CTRL+ALT",
+        symbols[Group1]= [ KP_Divide, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Ungrab ]
+    };
+};
diff --git a/xorg-server/xkeyboard-config/symbols/srvr_ctrl b/xorg-server/xkeyboard-config/symbols/srvr_ctrl
index 8bdf503a1..7d47d66a3 100644
--- a/xorg-server/xkeyboard-config/symbols/srvr_ctrl
+++ b/xorg-server/xkeyboard-config/symbols/srvr_ctrl
@@ -12,25 +12,25 @@ xkb_symbols "stdkeypad" {
 // Ungrab cancels server/keyboard/pointer grabs
     key <KPDV> {
 	type="CTRL+ALT",
-	symbols[Group1]= [ KP_Divide,	XF86_Ungrab ]
+	symbols[Group1]= [ KP_Divide, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Ungrab ]
     };
 
 // ClsGrb kills whichever client has a grab in effect
     key <KPMU> {
 	type="CTRL+ALT",
-	symbols[Group1]= [ KP_Multiply,	XF86_ClearGrab ]
+	symbols[Group1]= [ KP_Multiply, VoidSymbol, VoidSymbol, VoidSymbol, XF86_ClearGrab ]
     };
 
 // -VMode switches to the previous video mode
     key <KPSU> {
 	type="CTRL+ALT",
-	symbols[Group1]= [ KP_Subtract, XF86_Prev_VMode ]
+	symbols[Group1]= [ KP_Subtract, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Prev_VMode ]
     };
 
 // +VMode switches to the next video mode
     key <KPAD> {
 	type="CTRL+ALT",
-	symbols[Group1]= [ KP_Add,	XF86_Next_VMode]
+	symbols[Group1]= [ KP_Add, VoidSymbol, VoidSymbol, VoidSymbol, XF86_Next_VMode]
     };
 
 };
diff --git a/xorg-server/xkeyboard-config/symbols/terminate b/xorg-server/xkeyboard-config/symbols/terminate
index 8bb528cf8..96dd6e8f2 100644
--- a/xorg-server/xkeyboard-config/symbols/terminate
+++ b/xorg-server/xkeyboard-config/symbols/terminate
@@ -1,7 +1,7 @@
-partial default modifier_keys

-xkb_symbols "ctrl_alt_bksp" {

-    key <BKSP> {

-        type="CTRL+ALT",

-        symbols[Group1] = [ NoSymbol,        Terminate_Server ]

-    };

-};

+partial default modifier_keys
+xkb_symbols "ctrl_alt_bksp" {
+    key <BKSP> {
+        type="CTRL+ALT",
+        symbols[Group1] = [ NoSymbol, VoidSymbol, VoidSymbol, VoidSymbol, Terminate_Server ]
+    };
+};